From 50df0716c3e832e8e05801a1ff00c35171b38658 Mon Sep 17 00:00:00 2001 From: Ronaldo Davi Date: Mon, 13 Jul 2026 09:47:34 -0300 Subject: [PATCH 1/4] fix(quality): read cognitiveComplexity= machine line in validate-release-green (#7009) --- scripts/quality/validate-release-green.mjs | 9 ++++++++- tests/unit/validate-release-green.test.ts | 14 ++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/scripts/quality/validate-release-green.mjs b/scripts/quality/validate-release-green.mjs index db0933ed67a7..63f4f211a92d 100644 --- a/scripts/quality/validate-release-green.mjs +++ b/scripts/quality/validate-release-green.mjs @@ -126,7 +126,14 @@ export function parseEslintJson(out) { /** Pull the cognitive-complexity violation count from the gate's output. */ export function parseCognitiveCount(out) { - const m = String(out || "").match(/(\d+)\s+(?:function\(s\) exceed|violações|violations)/i); + const s = String(out || ""); + // `check:complexity-ratchets` runs ONE shared ESLint walk and prints BOTH ratchets, with the + // cyclomatic "N violações" summary emitted FIRST — so a bare `\d+ violações` regex would grab + // the cyclomatic count. Prefer the unambiguous machine-readable `cognitiveComplexity=N` line + // (mirrors the cyclomatic `complexity=N` parse used for cycCurrent below). + const machine = s.match(/(?:^|\n)cognitiveComplexity=(\d+)/); + if (machine) return Number(machine[1]); + const m = s.match(/(\d+)\s+(?:function\(s\) exceed|violações|violations)/i); return m ? Number(m[1]) : null; } diff --git a/tests/unit/validate-release-green.test.ts b/tests/unit/validate-release-green.test.ts index bf62fd80967a..762697526447 100644 --- a/tests/unit/validate-release-green.test.ts +++ b/tests/unit/validate-release-green.test.ts @@ -42,6 +42,20 @@ test("parseCognitiveCount reads the gate's count (en + pt)", () => { assert.equal(parseCognitiveCount("no number"), null); }); +test("parseCognitiveCount ignores the cyclomatic count in the combined ratchets output (#7009)", () => { + // `check:complexity-ratchets` runs ONE shared ESLint walk and prints BOTH ratchets. + // The cyclomatic "N violações" summary is emitted FIRST, so a bare `\\d+ violações` + // regex captured 2056 (cyclomatic) instead of 890 (cognitive) — a phantom drift in + // every pre-flight report. Prefer the unambiguous machine-readable `cognitiveComplexity=N`. + const combined = [ + "complexity=2056", + "cognitiveComplexity=890", + "[complexity] OK — 2056 violações (baseline 2056)", + "[cognitive-complexity] OK — 890 violações (baseline 890)", + ].join("\n"); + assert.equal(parseCognitiveCount(combined), 890); +}); + test("isDrift flags only growth past the committed baseline (down-direction ratchets)", () => { assert.equal(isDrift(3900, 3867), true); // grew → drift assert.equal(isDrift(3867, 3867), false); // equal → ok From 4d80e0a6692eb22bbf667f5dfcb283a3d6817dfc Mon Sep 17 00:00:00 2001 From: KooshaPari Date: Mon, 13 Jul 2026 19:49:31 -0700 Subject: [PATCH 2/4] fix(auto): use p95 fallback in speed factors --- .../autoCombo/__tests__/speedRanking.test.ts | 29 +++++++++++++++---- open-sse/services/autoCombo/speedRanking.ts | 10 +++++-- 2 files changed, 32 insertions(+), 7 deletions(-) diff --git a/open-sse/services/autoCombo/__tests__/speedRanking.test.ts b/open-sse/services/autoCombo/__tests__/speedRanking.test.ts index 1599e36b82f3..e3a4ad85f241 100644 --- a/open-sse/services/autoCombo/__tests__/speedRanking.test.ts +++ b/open-sse/services/autoCombo/__tests__/speedRanking.test.ts @@ -165,15 +165,34 @@ describe("rankBySpeed — factor breakdown", () => { }); it("falls back to 0.5 per missing metric so new providers are not crushed", () => { - const ranked = rankBySpeed([candidate({ provider: "fresh", model: "m" })]); + const ranked = rankBySpeed([ + candidate({ + provider: "fresh", + model: "m", + p95LatencyMs: undefined, + latencyStdDev: undefined, + }), + ]); expect(ranked).toHaveLength(1); // No telemetry at all → weighted sum lands near 0.5 with reliability multiplier 1 expect(ranked[0].factors.reliability).toBe(1); expect(ranked[0].factors.health).toBe(1); expect(ranked[0].factors.ttft).toBe(0.5); - expect(ranked[0].factors.tps).toBe(0.5); - }); -}); + expect(ranked[0].factors.tps).toBe(0.5); + }); + + it("uses p95 latency when TTFT and E2E telemetry are unavailable", () => { + const ranked = rankBySpeed([ + candidate({ provider: "slow-tail", model: "m", p95LatencyMs: 4000 }), + candidate({ provider: "fast-tail", model: "m", p95LatencyMs: 1000 }), + ]); + const fast = ranked.find((entry) => entry.provider === "fast-tail"); + const slow = ranked.find((entry) => entry.provider === "slow-tail"); + + expect(fast?.factors.ttft).toBeGreaterThan(slow?.factors.ttft ?? 1); + expect(fast?.factors.e2e).toBeGreaterThan(slow?.factors.e2e ?? 1); + }); +}); describe("rankBySpeed — weight overrides", () => { it("respects caller weight overrides (e.g. heavy TTFT bias)", () => { @@ -223,4 +242,4 @@ describe("pickFastest", () => { const winner = pickFastest([slow, fast]); expect(winner?.provider).toBe("fast"); }); -}); \ No newline at end of file +}); diff --git a/open-sse/services/autoCombo/speedRanking.ts b/open-sse/services/autoCombo/speedRanking.ts index 514420a5a06d..a3d7d8102738 100644 --- a/open-sse/services/autoCombo/speedRanking.ts +++ b/open-sse/services/autoCombo/speedRanking.ts @@ -211,9 +211,15 @@ function speedFactorsFor( failureRate: number ): SpeedFactors { return { - ttft: lowerIsBetter(positiveFinite(candidate.avgTtftMs), maxima.ttft), + ttft: lowerIsBetter( + positiveFinite(candidate.avgTtftMs) ?? positiveFinite(candidate.p95LatencyMs), + maxima.ttft + ), tps: higherIsBetter(positiveFinite(candidate.avgTokensPerSecond), maxima.tps), - e2e: lowerIsBetter(positiveFinite(candidate.avgE2ELatencyMs), maxima.e2e), + e2e: lowerIsBetter( + positiveFinite(candidate.avgE2ELatencyMs) ?? positiveFinite(candidate.p95LatencyMs), + maxima.e2e + ), p95: lowerIsBetter(positiveFinite(candidate.p95LatencyMs), maxima.p95), health: healthScoreFor(candidate.circuitBreakerState), reliability: clamp01(1 - failureRate), From fbe246f696f63f2744c5a3cb9cc04a7f76a89bf4 Mon Sep 17 00:00:00 2001 From: KooshaPari Date: Mon, 13 Jul 2026 23:07:22 -0700 Subject: [PATCH 3/4] Use OpenAI chunks for early chat keepalives --- open-sse/utils/earlyStreamKeepalive.ts | 6 ++++ src/app/api/v1/chat/completions/route.ts | 6 +++- tests/unit/early-stream-keepalive.test.ts | 34 ++++++++++++++++++++++- 3 files changed, 44 insertions(+), 2 deletions(-) diff --git a/open-sse/utils/earlyStreamKeepalive.ts b/open-sse/utils/earlyStreamKeepalive.ts index c70180f927d4..729049c9a33d 100644 --- a/open-sse/utils/earlyStreamKeepalive.ts +++ b/open-sse/utils/earlyStreamKeepalive.ts @@ -28,6 +28,12 @@ const ENCODER = new TextEncoder(); const KEEPALIVE_FRAME = ENCODER.encode(": omniroute-keepalive\n\n"); +// OpenAI-compatible keepalive: a syntactically valid empty streaming chunk. +// Some OpenAI-compatible clients parse every non-empty SSE line as JSON and +// reject legal SSE comments before their first provider chunk arrives. +export const OPENAI_KEEPALIVE_FRAME = ENCODER.encode( + 'data: {"id":"omniroute-keepalive","object":"chat.completion.chunk","created":0,"model":"omniroute","choices":[{"index":0,"delta":{},"finish_reason":null}]}\n\n' +); // Anthropic Messages-format keepalive: a REAL `ping` SSE event, not a comment. // Anthropic clients (Claude Code, the Anthropic SDK) reset their stream/first-token // watchdog on real SSE events but ignore SSE comments (`: ...`), so on a slow first diff --git a/src/app/api/v1/chat/completions/route.ts b/src/app/api/v1/chat/completions/route.ts index bddf765d0fed..2915d4730bca 100644 --- a/src/app/api/v1/chat/completions/route.ts +++ b/src/app/api/v1/chat/completions/route.ts @@ -5,7 +5,10 @@ import { generateRequestId } from "@/shared/utils/requestId"; import { initTranslators } from "@omniroute/open-sse/translator/index.ts"; import { createInjectionGuard } from "@/middleware/promptInjectionGuard"; import { acceptHeaderForcesStream } from "@omniroute/open-sse/utils/aiSdkCompat.ts"; -import { withEarlyStreamKeepalive } from "@omniroute/open-sse/utils/earlyStreamKeepalive"; +import { + OPENAI_KEEPALIVE_FRAME, + withEarlyStreamKeepalive, +} from "@omniroute/open-sse/utils/earlyStreamKeepalive"; import { resolveKeepaliveThreshold } from "@omniroute/open-sse/utils/keepaliveThreshold"; import { checkChatAdmission } from "@/shared/middleware/chatBodyAdmission"; import { @@ -132,6 +135,7 @@ export async function POST(request) { { signal: request.signal, thresholdMs: resolveKeepaliveThreshold(parsedBody?.model), + keepaliveFrame: OPENAI_KEEPALIVE_FRAME, extraHeaders: { "X-Correlation-Id": reqId }, } ); diff --git a/tests/unit/early-stream-keepalive.test.ts b/tests/unit/early-stream-keepalive.test.ts index a75c4c276412..5cd04ca1929c 100644 --- a/tests/unit/early-stream-keepalive.test.ts +++ b/tests/unit/early-stream-keepalive.test.ts @@ -4,6 +4,7 @@ import assert from "node:assert/strict"; import { withEarlyStreamKeepalive, ANTHROPIC_PING_FRAME, + OPENAI_KEEPALIVE_FRAME, } from "../../open-sse/utils/earlyStreamKeepalive.ts"; async function readAll(response: Response): Promise { @@ -68,9 +69,40 @@ test("ANTHROPIC_PING_FRAME is a real Anthropic ping event (not a comment)", () = assert.doesNotMatch(decoded, /^:/, "must not be an SSE comment"); }); +test("OPENAI_KEEPALIVE_FRAME is a JSON-parseable OpenAI streaming chunk", () => { + const decoded = new TextDecoder().decode(OPENAI_KEEPALIVE_FRAME); + assert.match(decoded, /^data: /); + assert.doesNotMatch(decoded, /^:/, "must not be an SSE comment"); + + const payload = JSON.parse(decoded.slice("data: ".length).trim()); + assert.equal(payload.object, "chat.completion.chunk"); + assert.deepEqual(payload.choices, [{ index: 0, delta: {}, finish_reason: null }]); +}); + +test("slow handler emits the custom OpenAI keepalive chunk before the body", async () => { + const slow = new Promise((resolve) => { + setTimeout(() => resolve(sseResponse("data: [DONE]\n\n")), 120); + }); + + const result = await withEarlyStreamKeepalive(slow, { + thresholdMs: 25, + intervalMs: 20, + keepaliveFrame: OPENAI_KEEPALIVE_FRAME, + }); + + const body = await readAll(result); + assert.doesNotMatch(body, /: omniroute-keepalive/); + const firstFrame = body.split("\n\n")[0]; + assert.doesNotThrow(() => JSON.parse(firstFrame.slice("data: ".length))); + assert.match(body, /data: \[DONE\]/); +}); + test("slow handler emits the custom keepaliveFrame (Anthropic ping) before the body", async () => { const slow = new Promise((resolve) => { - setTimeout(() => resolve(sseResponse("event: message_start\ndata: {}\n\ndata: [DONE]\n\n")), 120); + setTimeout( + () => resolve(sseResponse("event: message_start\ndata: {}\n\ndata: [DONE]\n\n")), + 120 + ); }); const result = await withEarlyStreamKeepalive(slow, { From e4994aec79a09be3649839388e34e5c7637d0aa4 Mon Sep 17 00:00:00 2001 From: KooshaPari Date: Tue, 14 Jul 2026 17:44:27 -0700 Subject: [PATCH 4/4] Update keepalive assertion to match chat completion chunk format --- tests/unit/chat-combo-live-test.test.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/unit/chat-combo-live-test.test.ts b/tests/unit/chat-combo-live-test.test.ts index a734b02bc4b9..79f8a35a32eb 100644 --- a/tests/unit/chat-combo-live-test.test.ts +++ b/tests/unit/chat-combo-live-test.test.ts @@ -274,7 +274,10 @@ test("chat completions route emits early keepalive while waiting for stream read assert.match(response.headers.get("content-type") || "", /text\/event-stream/); const body = await readAll(response); - assert.match(body, /: omniroute-keepalive/); + assert.match( + body, + /data: \{"id":"omniroute-keepalive","object":"chat\.completion\.chunk"/ + ); assert.match(body, /OK/); assert.match(body, /\[DONE\]/); });