fix(base-red): realign compression-disabled combo itest with #7379 context-window boundary

The 'disabled prompt compression leaves combo override requests unchanged'
integration test predates #7379 (enforceOutputTokenBudget): its 31.5k-token
body now trips the intentional pre-dispatch 400 context_length_exceeded
reject (test:integration only runs on the release-PR gate, so the red
accrued silently on the release branch). Resize the body into the
(70%-threshold, window) corridor — still proving disabled compression leaves
the request byte-identical — with a precondition locking the corridor, and
add chatcore-context-window-boundary.test.ts locking the reject path at the
integration layer (400 + context_length_exceeded + zero upstream fetches).
Red->green validated on the isolated file run.

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

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<string, unknown>
-      | undefined;
+      Record<string, unknown> | 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<string, unknown> | undefined;
     const userInputMessage = currentMessage?.userInputMessage as
-      | Record<string, unknown>
-      | undefined;
+      Record<string, unknown> | undefined;
     const currentContent =
       typeof userInputMessage?.content === "string" ? userInputMessage.content : "";
     assert.match(currentContent, /Please summarize everything\./);

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;
+    }
+  }
+});