diff --git a/changelog.d/maintenance/chatcore-compression-itest-ctx-boundary.md b/changelog.d/maintenance/chatcore-compression-itest-ctx-boundary.md new file mode 100644 index 0000000000..18c38ce8ad --- /dev/null +++ b/changelog.d/maintenance/chatcore-compression-itest-ctx-boundary.md @@ -0,0 +1 @@ +- fix(tests): realign the disabled-compression combo integration test with the #7379 pre-dispatch context-window boundary (body resized into the 70%-threshold↔window corridor) and add an integration lock (`chatcore-context-window-boundary`) asserting over-window requests are rejected with 400 `context_length_exceeded` before any upstream fetch diff --git a/tests/integration/chatcore-compression-integration.test.ts b/tests/integration/chatcore-compression-integration.test.ts index cd1b3a2ffb..a348848b0c 100644 --- a/tests/integration/chatcore-compression-integration.test.ts +++ b/tests/integration/chatcore-compression-integration.test.ts @@ -167,23 +167,25 @@ test("chatCore integration: disabled prompt compression leaves combo override re }, }); + // Body sits in (0.7*limit, limit): proves compression skip without the #7379 over-window reject. const body = { model: "combo/disabled-compression-combo", stream: false, messages: [ { role: "system", content: "You are helpful." }, - { role: "user", content: `${"Keep spacing.\n\n\n".repeat(2000)}First long turn.` }, + { role: "user", content: `${"Keep spacing.\n\n\n".repeat(450)}First long turn.` }, { role: "assistant", content: "Response 1" }, - { role: "user", content: `${"Keep spacing.\n\n\n".repeat(2000)}Second long turn.` }, + { role: "user", content: `${"Keep spacing.\n\n\n".repeat(450)}Second long turn.` }, { role: "assistant", content: "Response 2" }, - { role: "user", content: `${"Keep spacing.\n\n\n".repeat(2000)}Final question.` }, + { role: "user", content: `${"Keep spacing.\n\n\n".repeat(450)}Final question.` }, ], }; const contextLimit = getTokenLimit(provider, model); const proactiveThreshold = Math.floor(contextLimit * 0.7); + const estimatedBodyTokens = estimateTokens(JSON.stringify(body.messages)); assert.ok( - estimateTokens(JSON.stringify(body.messages)) > proactiveThreshold, - "Test body should exceed proactive compression threshold" + estimatedBodyTokens > proactiveThreshold && estimatedBodyTokens < contextLimit, + `Body tokens must sit in (${proactiveThreshold}, ${contextLimit}): ${estimatedBodyTokens}` ); let capturedBody: { messages?: Array<{ role?: string; content?: string }> } | null = null; @@ -570,8 +572,7 @@ test("chatCore integration: combo requests run proactive compression before Kiro // Ensure request was translated to Kiro shape (messages are not sent directly upstream). const conversationState = capturedTranslatedBody?.conversationState as - | Record - | undefined; + Record | undefined; assert.ok(conversationState, "Kiro translated request should include conversationState"); const history = Array.isArray(conversationState?.history) @@ -584,8 +585,7 @@ test("chatCore integration: combo requests run proactive compression before Kiro const currentMessage = conversationState?.currentMessage as Record | undefined; const userInputMessage = currentMessage?.userInputMessage as - | Record - | undefined; + Record | undefined; const currentContent = typeof userInputMessage?.content === "string" ? userInputMessage.content : ""; assert.match(currentContent, /Please summarize everything\./); diff --git a/tests/integration/chatcore-context-window-boundary.test.ts b/tests/integration/chatcore-context-window-boundary.test.ts new file mode 100644 index 0000000000..9d48704a6f --- /dev/null +++ b/tests/integration/chatcore-context-window-boundary.test.ts @@ -0,0 +1,106 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; + +const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-ctx-boundary-")); +process.env.DATA_DIR = TEST_DATA_DIR; +process.env.REQUIRE_API_KEY = "false"; +process.env.API_KEY_SECRET = process.env.API_KEY_SECRET || "test-ctx-boundary-secret"; + +const core = await import("../../src/lib/db/core.ts"); +const providersDb = await import("../../src/lib/db/providers.ts"); +const compressionDb = await import("../../src/lib/db/compression.ts"); +const { handleChatCore } = await import("../../open-sse/handlers/chatCore.ts"); +const { estimateTokens, getTokenLimit } = await import("../../open-sse/services/contextManager.ts"); + +const originalFetch = globalThis.fetch; + +test.after(async () => { + globalThis.fetch = originalFetch; + core.closeDbInstance(); + try { + fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true }); + } catch {} +}); + +// Integration lock for the pre-dispatch context-window boundary (#7379): +// enforceOutputTokenBudget in chatCore must reject a request whose input alone +// exceeds the target's context window — before any upstream fetch — when +// compression is disabled and therefore cannot reduce it. +test("chatCore integration: over-window request is rejected before dispatch when compression cannot reduce it", async () => { + const provider = "openai"; + const model = "gpt-4"; + const originalContextLength = process.env.CONTEXT_LENGTH_OPENAI; + process.env.CONTEXT_LENGTH_OPENAI = "8192"; + + await compressionDb.updateCompressionSettings({ + enabled: false, + defaultMode: "off", + autoTriggerTokens: 0, + }); + + const connection = await providersDb.createProviderConnection({ + provider, + apiKey: "test-key", + isActive: true, + }); + + const body = { + model, + stream: false, + messages: [ + { role: "system", content: "You are helpful." }, + { role: "user", content: `${"Keep spacing.\n\n\n".repeat(2000)}Way over the window.` }, + ], + }; + assert.ok( + estimateTokens(JSON.stringify(body.messages)) > getTokenLimit(provider, model), + "Test body should exceed the full context window" + ); + + let fetchCalls = 0; + globalThis.fetch = async () => { + fetchCalls += 1; + return new Response( + JSON.stringify({ + choices: [{ message: { role: "assistant", content: "test" } }], + usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 }, + }), + { + status: 200, + headers: { "content-type": "application/json" }, + } + ); + }; + + try { + const result = await handleChatCore({ + body, + modelInfo: { provider, model }, + credentials: { apiKey: "test-key" }, + log: { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} }, + clientRawRequest: { endpoint: "/v1/chat/completions", headers: new Map() }, + connectionId: connection.id, + onCredentialsRefreshed: () => {}, + onRequestSuccess: () => {}, + onStreamFailure: () => {}, + onDisconnect: () => {}, + userAgent: "test-agent", + comboName: null, + }); + + assert.equal(result.success, false, "Over-window request should be rejected"); + assert.equal(result.status, 400); + assert.equal(result.errorCode, "context_length_exceeded"); + assert.equal(fetchCalls, 0, "Rejected request must never reach the upstream"); + } finally { + globalThis.fetch = originalFetch; + if (originalContextLength === undefined) { + delete process.env.CONTEXT_LENGTH_OPENAI; + } else { + process.env.CONTEXT_LENGTH_OPENAI = originalContextLength; + } + } +});