@velum-labs/routekit-gateway 0.9.4 → 0.9.6

package/dist/adapters/cursor.d.ts

@@ -22,6 +22,24 @@ type JsonObject = Record<string, unknown>;
  * job; the translation itself stays total.
  */
 export declare function isCursorChatBody(body: unknown): body is JsonObject;
+/**
+ * Spell a namespaced model id the way Cursor's custom-model settings accept
+ * it. Cursor rejects ids containing "/" ("Model name is not valid"), so the
+ * cursor route advertises and answers to a dash-separated spelling
+ * (`claude-code/claude-fable-5` -> `claude-code-claude-fable-5`). Dashes are
+ * preferred over dots because dotted names can collide with Cursor's managed
+ * model catalog.
+ */
+export declare function cursorModelAliasId(id: string): string;
+/**
+ * Resolve Cursor's dash-separated spelling back to a served namespaced id.
+ *
+ * Resolution is an exact lookup over the gateway's served ids rather than a
+ * separator split, because namespaces themselves contain dashes. A rewrite
+ * only happens when the model is not served as spelled; if two served ids
+ * produce the same alias, the first one listed wins.
+ */
+export declare function resolveCursorModelAlias(model: unknown, servedIds: readonly string[]): string | undefined;
 /**
  * Map a Cursor BYOK request body onto a Chat Completions body.
  *

package/dist/adapters/cursor.js

@@ -40,6 +40,31 @@ function isObject(value) {
 export function isCursorChatBody(body) {
     return isObject(body) && ("messages" in body || "input" in body);
 }
+/**
+ * Spell a namespaced model id the way Cursor's custom-model settings accept
+ * it. Cursor rejects ids containing "/" ("Model name is not valid"), so the
+ * cursor route advertises and answers to a dash-separated spelling
+ * (`claude-code/claude-fable-5` -> `claude-code-claude-fable-5`). Dashes are
+ * preferred over dots because dotted names can collide with Cursor's managed
+ * model catalog.
+ */
+export function cursorModelAliasId(id) {
+    return id.replace("/", "-");
+}
+/**
+ * Resolve Cursor's dash-separated spelling back to a served namespaced id.
+ *
+ * Resolution is an exact lookup over the gateway's served ids rather than a
+ * separator split, because namespaces themselves contain dashes. A rewrite
+ * only happens when the model is not served as spelled; if two served ids
+ * produce the same alias, the first one listed wins.
+ */
+export function resolveCursorModelAlias(model, servedIds) {
+    if (typeof model !== "string" || model.length === 0 || servedIds.includes(model)) {
+        return undefined;
+    }
+    return servedIds.find((id) => id.includes("/") && cursorModelAliasId(id) === model);
+}
 /**
  * Map a Cursor BYOK request body onto a Chat Completions body.
  *

package/dist/provider-backends.js

@@ -870,6 +870,26 @@ function responsesOutput(payload) {
         ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {})
     };
 }
+const CODEX_EMPTY_RESPONSE_ERROR = {
+    message: "Codex completed without assistant content or tool calls",
+    type: "upstream_empty_response"
+};
+function responsesItemText(item) {
+    if (item.type !== "message")
+        return "";
+    const content = item.content;
+    return (content ?? [])
+        .flatMap((part) => typeof part.text === "string" ? [part.text] : [])
+        .join("");
+}
+function codexCompletionResponse(model, payload) {
+    const message = responsesOutput(payload);
+    const hasOutput = (typeof message.content === "string" && message.content.length > 0) ||
+        (Array.isArray(message.tool_calls) && message.tool_calls.length > 0);
+    return hasOutput
+        ? jsonResponse(chatCompletion(model, message, normalizedOpenAiUsage(payload.usage)))
+        : jsonResponse({ error: CODEX_EMPTY_RESPONSE_ERROR }, 502);
+}
 export class CodexResponsesBackend extends HttpProviderBackend {
     #accountId;
     #forceStream;
@@ -912,10 +932,31 @@ export class CodexResponsesBackend extends HttpProviderBackend {
             return copyFailure(response, await response.text());
         if (body.stream === true) {
             let hasToolCalls = false;
+            let hasAssistantContent = false;
+            const emittedText = new Map();
+            const contentChunk = (content) => ({
+                id: randomId(18, "chatcmpl_"),
+                object: "chat.completion.chunk",
+                model,
+                choices: [{ index: 0, delta: { content }, finish_reason: null }]
+            });
+            const recoverMessage = (output, outputIndex) => {
+                const complete = responsesItemText(output);
+                const previous = emittedText.get(outputIndex) ?? "";
+                const suffix = complete.startsWith(previous)
+                    ? complete.slice(previous.length)
+                    : "";
+                if (suffix.length === 0)
+                    return [];
+                emittedText.set(outputIndex, complete);
+                hasAssistantContent = true;
+                return [contentChunk(suffix)];
+            };
             return mapSse(response, (event, data) => {
                 const item = data;
-                if (event === "response.reasoning_summary_text.delta" ||
-                    event === "response.reasoning_text.delta") {
+                const eventType = event === "message" && typeof item.type === "string" ? item.type : event;
+                if (eventType === "response.reasoning_summary_text.delta" ||
+                    eventType === "response.reasoning_text.delta") {
                     return [
                         {
                             id: randomId(18, "chatcmpl_"),
@@ -931,17 +972,16 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                         }
                     ];
                 }
-                if (event === "response.output_text.delta") {
-                    return [
-                        {
-                            id: randomId(18, "chatcmpl_"),
-                            object: "chat.completion.chunk",
-                            model,
-                            choices: [{ index: 0, delta: { content: item.delta }, finish_reason: null }]
-                        }
-                    ];
+                if (eventType === "response.output_text.delta") {
+                    const outputIndex = typeof item.output_index === "number" ? item.output_index : 0;
+                    const delta = typeof item.delta === "string" ? item.delta : "";
+                    emittedText.set(outputIndex, `${emittedText.get(outputIndex) ?? ""}${delta}`);
+                    if (delta.length === 0)
+                        return [];
+                    hasAssistantContent = true;
+                    return [contentChunk(delta)];
                 }
-                if (event === "response.function_call_arguments.delta") {
+                if (eventType === "response.function_call_arguments.delta") {
                     return [
                         {
                             id: randomId(18, "chatcmpl_"),
@@ -964,7 +1004,7 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                         }
                     ];
                 }
-                if (event === "response.output_item.added") {
+                if (eventType === "response.output_item.added") {
                     const output = item.item;
                     if (output?.type !== "function_call")
                         return [];
@@ -993,9 +1033,27 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                         }
                     ];
                 }
-                if (event === "response.completed") {
+                if (eventType === "response.output_item.done") {
+                    const output = item.item;
+                    if (output?.type !== "message")
+                        return [];
+                    const outputIndex = typeof item.output_index === "number" ? item.output_index : 0;
+                    return recoverMessage(output, outputIndex);
+                }
+                if (eventType === "response.completed") {
                     const completed = item.response;
+                    const recovered = Array.isArray(completed?.output)
+                        ? completed.output.flatMap((output, outputIndex) => typeof output === "object" &&
+                            output !== null &&
+                            output.type === "message"
+                            ? recoverMessage(output, outputIndex)
+                            : [])
+                        : [];
+                    if (!hasAssistantContent && !hasToolCalls) {
+                        return [...recovered, { error: CODEX_EMPTY_RESPONSE_ERROR }];
+                    }
                     return [
+                        ...recovered,
                         {
                             id: randomId(18, "chatcmpl_"),
                             object: "chat.completion.chunk",
@@ -1013,6 +1071,18 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                         }
                     ];
                 }
+                if (eventType === "response.failed" ||
+                    eventType === "response.incomplete" ||
+                    eventType === "error") {
+                    return [
+                        {
+                            error: {
+                                message: "Codex response did not complete",
+                                type: "upstream_error"
+                            }
+                        }
+                    ];
+                }
                 return [];
             });
         }
@@ -1022,7 +1092,7 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                 ...decoder.feed(await response.text()),
                 ...decoder.flush()
             ];
-            const completedOutput = [];
+            const completedOutput = new Map();
             let completedResponse;
             for (const event of events) {
                 let payload;
@@ -1043,7 +1113,10 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                 if (eventType === "response.output_item.done" &&
                     typeof record.item === "object" &&
                     record.item !== null) {
-                    completedOutput.push(record.item);
+                    const outputIndex = typeof record.output_index === "number"
+                        ? record.output_index
+                        : completedOutput.size;
+                    completedOutput.set(outputIndex, record.item);
                 }
                 if (eventType === "response.completed" &&
                     typeof record.response === "object" &&
@@ -1052,16 +1125,20 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                 }
             }
             if (completedResponse !== undefined) {
-                const terminalOutput = completedResponse.output;
-                const payload = (!Array.isArray(terminalOutput) || terminalOutput.length === 0) &&
-                    completedOutput.length > 0
-                    ? { ...completedResponse, output: completedOutput }
-                    : completedResponse;
-                return jsonResponse(chatCompletion(model, responsesOutput(payload), normalizedOpenAiUsage(payload.usage)));
+                const terminalOutput = Array.isArray(completedResponse.output)
+                    ? [...completedResponse.output]
+                    : [];
+                for (const [outputIndex, output] of completedOutput) {
+                    if (terminalOutput[outputIndex] === undefined) {
+                        terminalOutput[outputIndex] = output;
+                    }
+                }
+                const payload = { ...completedResponse, output: terminalOutput };
+                return codexCompletionResponse(model, payload);
             }
             throw new SseParseError("provider SSE stream ended without response.completed");
         }
         const payload = (await response.json());
-        return jsonResponse(chatCompletion(model, responsesOutput(payload), normalizedOpenAiUsage(payload.usage)));
+        return codexCompletionResponse(model, payload);
     }
 }

package/dist/provider-source.js

@@ -63,16 +63,52 @@ function reasoningWireShape(provider) {
             return undefined;
     }
 }
+const ANTHROPIC_EFFORT_ORDER = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+];
+function capabilitySupported(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (!isRecord(value) || typeof value.supported !== "boolean") {
+        return undefined;
+    }
+    return value.supported;
+}
 export function parseReasoningCapabilities(entry, provider, refreshedAt = new Date().toISOString()) {
     if (!isRecord(entry))
         return undefined;
     const capabilities = isRecord(entry.capabilities) ? entry.capabilities : undefined;
     const nested = (isRecord(entry.reasoning) ? entry.reasoning : undefined) ??
         (isRecord(capabilities?.reasoning) ? capabilities.reasoning : undefined);
-    const efforts = effortOptions(entry.supported_reasoning_levels ??
+    const discoveredEfforts = effortOptions(entry.supported_reasoning_levels ??
         entry.supported_reasoning_efforts ??
         nested?.efforts ??
         nested?.supported_efforts);
+    const anthropicEffort = provider === "anthropic" || provider === "claude-code"
+        ? isRecord(capabilities?.effort)
+            ? capabilities.effort
+            : undefined
+        : undefined;
+    const anthropicThinking = provider === "anthropic" || provider === "claude-code"
+        ? isRecord(capabilities?.thinking)
+            ? capabilities.thinking
+            : undefined
+        : undefined;
+    const thinkingTypes = isRecord(anthropicThinking?.types)
+        ? anthropicThinking.types
+        : undefined;
+    const effortSupported = capabilitySupported(anthropicEffort?.supported);
+    const thinkingSupported = capabilitySupported(anthropicThinking?.supported);
+    const adaptiveSupported = capabilitySupported(thinkingTypes?.adaptive);
+    const enabledSupported = capabilitySupported(thinkingTypes?.enabled);
+    const anthropicEfforts = effortSupported === true
+        ? ANTHROPIC_EFFORT_ORDER.flatMap((id) => capabilitySupported(anthropicEffort?.[id]) === true ? [{ id }] : [])
+        : [];
+    const efforts = discoveredEfforts.length > 0 ? discoveredEfforts : anthropicEfforts;
     const supportedParameters = Array.isArray(entry.supported_parameters)
         ? entry.supported_parameters.filter((parameter) => typeof parameter === "string")
         : [];
@@ -80,12 +116,20 @@ export function parseReasoningCapabilities(entry, provider, refreshedAt = new Da
         capabilities?.reasoning_controls ??
         entry.reasoning_controls;
     const supported = efforts.length > 0 ||
+        effortSupported === true ||
+        thinkingSupported === true ||
+        adaptiveSupported === true ||
+        enabledSupported === true ||
         supportedParameters.includes("reasoning") ||
         supportedParameters.includes("reasoning_effort") ||
         explicitStatus === "supported";
-    const unsupported = explicitStatus === "unsupported" || nested?.supported === false;
-    if (!supported && !unsupported && nested === undefined)
+    const unsupported = explicitStatus === "unsupported" ||
+        nested?.supported === false ||
+        (effortSupported === false && thinkingSupported === false);
+    const hasAnthropicMetadata = anthropicEffort !== undefined || anthropicThinking !== undefined;
+    if (!supported && !unsupported && nested === undefined && !hasAnthropicMetadata) {
         return undefined;
+    }
     const defaultEffort = typeof entry.default_reasoning_level === "string"
         ? entry.default_reasoning_level
         : typeof nested?.default_effort === "string"
@@ -94,7 +138,7 @@ export function parseReasoningCapabilities(entry, provider, refreshedAt = new Da
                 ? nested.defaultEffort
                 : undefined;
     const budgetSource = isRecord(nested?.budget) ? nested.budget : undefined;
-    const budget = budgetSource === undefined
+    const nestedBudget = budgetSource === undefined
         ? undefined
         : {
             ...(typeof budgetSource.min_tokens === "number"
@@ -113,12 +157,16 @@ export function parseReasoningCapabilities(entry, provider, refreshedAt = new Da
                     ? { defaultTokens: budgetSource.defaultTokens }
                     : {})
         };
+    const budget = nestedBudget ?? (enabledSupported === true ? { minTokens: 1_024 } : undefined);
+    const adaptive = typeof nested?.adaptive === "boolean"
+        ? nested.adaptive
+        : adaptiveSupported;
     return {
         status: unsupported ? "unsupported" : supported ? "supported" : "unknown",
         ...(efforts.length > 0 ? { efforts } : {}),
         ...(defaultEffort !== undefined ? { defaultEffort } : {}),
         ...(budget !== undefined ? { budget } : {}),
-        ...(typeof nested?.adaptive === "boolean" ? { adaptive: nested.adaptive } : {}),
+        ...(adaptive !== undefined ? { adaptive } : {}),
         ...(reasoningWireShape(provider) !== undefined
             ? { wireShape: reasoningWireShape(provider) }
             : {}),

package/dist/server.js

@@ -4,7 +4,7 @@ import { ProviderFailureError } from "@velum-labs/routekit-contracts";
 import { anthropicModelsResponse, handleAnthropicMessages, handleCountTokens, resolveClaudeModelAlias } from "./adapters/anthropic.js";
 import { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
 import { authorizedRequest } from "./auth.js";
-import { isCursorChatBody, translateCursorRequest } from "./adapters/cursor.js";
+import { cursorModelAliasId, isCursorChatBody, resolveCursorModelAlias, translateCursorRequest } from "./adapters/cursor.js";
 import { handleResponses } from "./adapters/responses.js";
 import { validateAnthropicRequest, validateChatRequest, validateCountTokensRequest, validateResponsesRequest } from "./adapters/validate.js";
 import { buildModelCallRecord, MODEL_CALL_ID_HEADER, modelCallId } from "./provenance.js";
@@ -273,9 +273,22 @@ export async function startGateway(options) {
             return;
         }
         // Cursor may probe the models list relative to its BYOK base URL
-        // (`.../v1/cursor`); mirror /v1/models there.
+        // (`.../v1/cursor`); mirror /v1/models there. Namespaced ids are respelled
+        // with dashes because Cursor's custom-model settings reject "/" in names;
+        // the chat route below resolves the dashed spelling back.
         if (method === "GET" && path === "/v1/cursor/models") {
-            await pipeUpstream(res, await backend.models());
+            const upstream = await backend.models();
+            if (!upstream.ok) {
+                await pipeUpstream(res, upstream);
+                return;
+            }
+            const payload = (await upstream.json());
+            writeJson(res, 200, {
+                ...payload,
+                data: (payload.data ?? []).map((entry) => typeof entry.id === "string"
+                    ? { ...entry, id: cursorModelAliasId(entry.id) }
+                    : entry)
+            });
             return;
         }
         // Anthropic single-model retrieve (`GET /v1/models/{id}`): Claude Code probes
@@ -349,6 +362,9 @@ export async function startGateway(options) {
             const translated = translateCursorRequest(raw);
             if (rejectInvalid(res, validateChatRequest(translated)))
                 return;
+            const aliased = resolveCursorModelAlias(translated.model, backend.listModelIds?.() ?? []);
+            if (aliased !== undefined)
+                translated.model = aliased;
             const body = withDefaultModel(translated, backend.defaultModel);
             await handleModelCall(res, provenance, {
                 dialect: "openai-chat",

package/dist/test/cursor.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { isCursorChatBody, translateCursorRequest } from "../adapters/cursor.js";
+import { cursorModelAliasId, isCursorChatBody, resolveCursorModelAlias, translateCursorRequest } from "../adapters/cursor.js";
 import { startGateway } from "../server.js";
 const cursorBody = {
     model: "route-primary",
@@ -47,6 +47,18 @@ test("Cursor hybrid requests translate to chat messages and tools", () => {
     ]);
     assert.equal(translated.tools[0]?.function.name, "read_file");
 });
+test("Cursor model aliases respell namespaced ids with dashes", () => {
+    assert.equal(cursorModelAliasId("claude-code/claude-fable-5"), "claude-code-claude-fable-5");
+    assert.equal(cursorModelAliasId("openai/gpt-4o"), "openai-gpt-4o");
+    assert.equal(cursorModelAliasId("route-primary"), "route-primary");
+    const served = ["claude-code/claude-fable-5", "openai/gpt-4o", "route-primary"];
+    assert.equal(resolveCursorModelAlias("claude-code-claude-fable-5", served), "claude-code/claude-fable-5");
+    assert.equal(resolveCursorModelAlias("openai-gpt-4o", served), "openai/gpt-4o");
+    // Served-as-spelled ids and unknown names never rewrite.
+    assert.equal(resolveCursorModelAlias("route-primary", served), undefined);
+    assert.equal(resolveCursorModelAlias("claude-fable-5", served), undefined);
+    assert.equal(resolveCursorModelAlias(undefined, served), undefined);
+});
 test("Cursor hybrid detection rejects unrelated bodies", () => {
     assert.equal(isCursorChatBody({ input: "hello" }), true);
     assert.equal(isCursorChatBody({ messages: [] }), true);
@@ -98,3 +110,53 @@ test("RouteKit serves the Cursor hybrid through its neutral HTTP boundary", asyn
         await gateway.close();
     }
 });
+test("Cursor route resolves dashed model aliases to namespaced ids", async () => {
+    let received;
+    const backend = {
+        defaultModel: "claude-code/claude-fable-5",
+        chat(body) {
+            received = body;
+            return Promise.resolve(Response.json({
+                id: "chatcmpl_2",
+                object: "chat.completion",
+                model: "claude-code/claude-fable-5",
+                choices: [
+                    {
+                        index: 0,
+                        message: { role: "assistant", content: "done" },
+                        finish_reason: "stop"
+                    }
+                ]
+            }));
+        },
+        models: () => Promise.resolve(Response.json({
+            object: "list",
+            data: [
+                { id: "claude-code/claude-fable-5", object: "model" },
+                { id: "openai/gpt-4o", object: "model" }
+            ]
+        })),
+        listModelIds: () => ["claude-code/claude-fable-5", "openai/gpt-4o"],
+        embeddings: () => Promise.resolve(new Response(null, { status: 501 }))
+    };
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/cursor/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "claude-code-claude-fable-5",
+                messages: [{ role: "user", content: "hi" }]
+            })
+        });
+        assert.equal(response.status, 200);
+        assert.equal(received?.model, "claude-code/claude-fable-5");
+        // The models mirror advertises the dashed spelling Cursor accepts.
+        const models = await fetch(`${gateway.url()}/v1/cursor/models`);
+        assert.equal(models.status, 200);
+        assert.deepEqual((await models.json()).data.map((model) => model.id), ["claude-code-claude-fable-5", "openai-gpt-4o"]);
+    }
+    finally {
+        await gateway.close();
+    }
+});

package/dist/test/provider-backends.test.js

@@ -3,7 +3,8 @@ import { test } from "node:test";
 import { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "../provider-backends.js";
 import { anthropicToChat } from "../adapters/anthropic.js";
 import { attachReasoningSelection } from "../adapters/openai-chat-wire.js";
-import { SseParseError } from "../sse/parse.js";
+import { ChatStreamAssembler } from "../sse/chat-assembler.js";
+import { SseDecoder, SseParseError } from "../sse/parse.js";
 function sse(events, includeDone = false) {
     const body = events
         .map(({ event, data }) => `${event === undefined ? "" : `event: ${event}\n`}data: ${JSON.stringify(data)}\n\n`)
@@ -437,6 +438,294 @@ test("Codex subscription egress recovers output from completed stream items", as
         globalThis.fetch = original;
     }
 });
+test("Codex subscription egress merges completed items into partial terminal output", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = async () => sse([
+        {
+            event: "response.output_item.done",
+            data: {
+                item: {
+                    type: "reasoning",
+                    summary: [{ type: "summary_text", text: "brief reasoning" }]
+                },
+                output_index: 0
+            }
+        },
+        {
+            event: "response.output_item.done",
+            data: {
+                item: {
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: "RouteKit works" }]
+                },
+                output_index: 1
+            }
+        },
+        {
+            event: "response.completed",
+            data: {
+                response: {
+                    output: [
+                        {
+                            type: "reasoning",
+                            summary: [{ type: "summary_text", text: "brief reasoning" }]
+                        }
+                    ],
+                    usage: { input_tokens: 8, output_tokens: 8, total_tokens: 16 }
+                }
+            }
+        }
+    ]);
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "gpt-5.5",
+            forceStream: true,
+            omitSampling: true
+        });
+        const response = await backend.chat({
+            stream: false,
+            messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+        });
+        const body = (await response.json());
+        assert.equal(response.status, 200);
+        assert.equal(body.choices[0]?.message.content, "RouteKit works");
+        assert.equal(body.choices[0]?.message.reasoning, "brief reasoning");
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription streaming recovers text when only the completed item carries it", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = async () => sse([
+        {
+            data: {
+                type: "response.output_item.done",
+                item: {
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: "RouteKit works" }]
+                },
+                output_index: 0
+            }
+        },
+        {
+            data: {
+                type: "response.completed",
+                response: {
+                    output: [],
+                    usage: { input_tokens: 8, output_tokens: 5, total_tokens: 13 }
+                }
+            }
+        }
+    ]);
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "gpt-5.5",
+            forceStream: true,
+            omitSampling: true
+        });
+        const response = await backend.chat({
+            stream: true,
+            messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+        });
+        const text = await response.text();
+        assert.match(text, /"content":"RouteKit works"/);
+        assert.match(text, /"finish_reason":"stop"/);
+        assert.match(text, /"completion_tokens":5/);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription streaming does not duplicate delta and completed-item text", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = async () => sse([
+        {
+            event: "response.output_text.delta",
+            data: { output_index: 0, delta: "RouteKit " }
+        },
+        {
+            event: "response.output_item.done",
+            data: {
+                item: {
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "output_text", text: "RouteKit works" }]
+                },
+                output_index: 0
+            }
+        },
+        {
+            event: "response.completed",
+            data: {
+                response: {
+                    output: [
+                        {
+                            type: "message",
+                            role: "assistant",
+                            content: [{ type: "output_text", text: "RouteKit works" }]
+                        }
+                    ],
+                    usage: { input_tokens: 8, output_tokens: 5, total_tokens: 13 }
+                }
+            }
+        }
+    ]);
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "gpt-5.5"
+        });
+        const response = await backend.chat({
+            stream: true,
+            messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+        });
+        const decoder = new SseDecoder();
+        const events = [
+            ...decoder.feed(await response.text()),
+            ...decoder.flush()
+        ];
+        const assembler = new ChatStreamAssembler();
+        for (const event of events)
+            assembler.push(event);
+        assert.equal(assembler.result().content, "RouteKit works");
+        assert.equal(assembler.result().finishReason, "stop");
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription egress rejects a silent reasoning-only completion", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = async () => sse([
+        {
+            data: {
+                type: "response.output_item.done",
+                item: {
+                    type: "reasoning",
+                    summary: [{ type: "summary_text", text: "internal reasoning" }]
+                },
+                output_index: 0
+            }
+        },
+        {
+            data: {
+                type: "response.completed",
+                response: {
+                    output: [],
+                    usage: {
+                        input_tokens: 22,
+                        output_tokens: 31,
+                        output_tokens_details: { reasoning_tokens: 22 },
+                        total_tokens: 53
+                    }
+                }
+            }
+        }
+    ]);
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "gpt-5.5",
+            forceStream: true,
+            omitSampling: true
+        });
+        const response = await backend.chat({
+            stream: false,
+            messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+        });
+        assert.equal(response.status, 502);
+        assert.deepEqual(await response.json(), {
+            error: {
+                message: "Codex completed without assistant content or tool calls",
+                type: "upstream_empty_response"
+            }
+        });
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription streaming surfaces a silent reasoning-only completion as an error", async () => {
+    const original = globalThis.fetch;
+    globalThis.fetch = async () => sse([
+        {
+            event: "response.reasoning_summary_text.delta",
+            data: { output_index: 0, delta: "internal reasoning" }
+        },
+        {
+            event: "response.completed",
+            data: {
+                response: {
+                    output: [],
+                    usage: {
+                        input_tokens: 22,
+                        output_tokens: 31,
+                        output_tokens_details: { reasoning_tokens: 22 },
+                        total_tokens: 53
+                    }
+                }
+            }
+        }
+    ]);
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "gpt-5.5"
+        });
+        const response = await backend.chat({
+            stream: true,
+            messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+        });
+        const text = await response.text();
+        assert.match(text, /"type":"upstream_empty_response"/);
+        assert.doesNotMatch(text, /"finish_reason":"stop"/);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription streaming surfaces terminal failure events", async () => {
+    const original = globalThis.fetch;
+    const backend = new CodexResponsesBackend({
+        baseUrl: "https://chatgpt.test/backend-api/codex",
+        apiKey: "oauth",
+        defaultModel: "gpt-5.5"
+    });
+    try {
+        for (const terminal of [
+            { event: "response.failed", data: { response: { status: "failed" } } },
+            {
+                event: "response.incomplete",
+                data: { response: { status: "incomplete" } }
+            },
+            {
+                data: { type: "response.failed", response: { status: "failed" } }
+            }
+        ]) {
+            globalThis.fetch = async () => sse([terminal]);
+            const response = await backend.chat({
+                stream: true,
+                messages: [{ role: "user", content: "Reply with: RouteKit works" }]
+            });
+            const text = await response.text();
+            assert.match(text, /"type":"upstream_error"/);
+            assert.doesNotMatch(text, /"finish_reason":"stop"/);
+        }
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
 test("Anthropic streaming egress preserves tool calls and terminal usage", async () => {
     const original = globalThis.fetch;
     globalThis.fetch = async () => sse([

package/dist/test/provider-source.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/provider-source.test.js

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseDiscoveredModels } from "../provider-source.js";
+test("Anthropic discovery projects authoritative effort and thinking capabilities", () => {
+    const [model] = parseDiscoveredModels("anthropic", {
+        data: [
+            {
+                id: "claude-fable-5",
+                capabilities: {
+                    effort: {
+                        supported: true,
+                        low: { supported: true },
+                        medium: { supported: false },
+                        high: { supported: true },
+                        xhigh: null,
+                        max: { supported: true }
+                    },
+                    thinking: {
+                        supported: true,
+                        types: {
+                            adaptive: { supported: true },
+                            enabled: { supported: true }
+                        }
+                    }
+                }
+            }
+        ]
+    }, "claude-code");
+    assert.deepEqual(model?.reasoning, {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "high" }, { id: "max" }],
+        budget: { minTokens: 1_024 },
+        adaptive: true,
+        wireShape: "anthropic",
+        provenance: "provider",
+        refreshedAt: model?.reasoning?.refreshedAt
+    });
+    assert.equal(model?.reasoning?.defaultEffort, undefined);
+});
+test("Anthropic discovery preserves explicit unsupported and missing capabilities", () => {
+    const models = parseDiscoveredModels("anthropic", {
+        data: [
+            {
+                id: "claude-no-reasoning",
+                capabilities: {
+                    effort: { supported: false },
+                    thinking: {
+                        supported: false,
+                        types: {
+                            adaptive: { supported: false },
+                            enabled: { supported: false }
+                        }
+                    }
+                }
+            },
+            { id: "claude-unknown" }
+        ]
+    }, "claude-code");
+    assert.deepEqual(models[0]?.reasoning, {
+        status: "unsupported",
+        adaptive: false,
+        wireShape: "anthropic",
+        provenance: "provider",
+        refreshedAt: models[0]?.reasoning?.refreshedAt
+    });
+    assert.equal(models[1]?.reasoning, undefined);
+});

package/dist/test/responses.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { createServer } from "node:http";
 import { test } from "node:test";
 import { OpenAiBackend } from "../backend.js";
+import { AnthropicBackend } from "../provider-backends.js";
 import { MODEL_CALL_ID_HEADER } from "../provenance.js";
 import { CatalogBackend } from "../router.js";
 import { chatToResponses, customToolNames, openAiSseToResponses, responsesToChat, responsesToolRegistry } from "../adapters/responses.js";
@@ -225,6 +226,86 @@ test("serves a Responses request carrying reasoning: null end to end", async ()
         await mock.close();
     }
 });
+test("Responses routes discovered Claude efforts to adaptive Anthropic egress", async () => {
+    const requests = [];
+    const anthropic = new AnthropicBackend({
+        baseUrl: "https://api.anthropic.test/v1",
+        apiKey: "unused",
+        transport: async (input, init) => {
+            requests.push(new Request(input, init));
+            return Response.json({
+                id: "msg_fable",
+                type: "message",
+                role: "assistant",
+                model: "claude-fable-5",
+                content: [{ type: "text", text: "FABLE_OK" }],
+                stop_reason: "end_turn",
+                usage: { input_tokens: 1, output_tokens: 1 }
+            });
+        }
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { "claude-code": {} },
+            defaultModel: "claude-code/claude-fable-5"
+        },
+        sources: {
+            "claude-code": {
+                sourceId: "claude-code",
+                async discoverModels() {
+                    return [
+                        {
+                            id: "claude-fable-5",
+                            reasoning: {
+                                status: "supported",
+                                efforts: [{ id: "low" }, { id: "high" }],
+                                budget: { minTokens: 1_024 },
+                                adaptive: true,
+                                wireShape: "anthropic",
+                                provenance: "provider"
+                            }
+                        }
+                    ];
+                },
+                chat: (body, signal, options) => anthropic.chat(body, signal, options),
+                embeddings: async () => Response.json({})
+            }
+        }
+    });
+    const gateway = await startGateway({ backend });
+    try {
+        const supported = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "claude-code/claude-fable-5",
+                input: "hi",
+                max_output_tokens: 64,
+                reasoning: { effort: "high" }
+            })
+        });
+        assert.equal(supported.status, 200);
+        const outbound = (await requests[0]?.json());
+        assert.deepEqual(outbound.thinking, { type: "adaptive" });
+        assert.deepEqual(outbound.output_config, { effort: "high" });
+        const unsupported = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "claude-code/claude-fable-5",
+                input: "hi",
+                reasoning: { effort: "max" }
+            })
+        });
+        assert.equal(unsupported.status, 400);
+        assert.equal((await unsupported.json()).error
+            ?.message, 'reasoning effort "max" is not supported by model "claude-code/claude-fable-5"');
+        assert.equal(requests.length, 1);
+    }
+    finally {
+        await gateway.close();
+    }
+});
 test("serves a Responses request with null optional fields end to end", async () => {
     const mock = await startMock();
     const gateway = await startGateway({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.9.4",
+  "version": "0.9.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/handoffkit.git",
@@ -27,10 +27,10 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@velum-labs/routekit-registry": "0.9.4",
-    "@velum-labs/routekit-runtime": "0.9.4",
-    "@velum-labs/routekit-contracts": "0.9.4",
-    "@velum-labs/routekit-tracing": "0.9.4"
+    "@velum-labs/routekit-contracts": "0.9.6",
+    "@velum-labs/routekit-registry": "0.9.6",
+    "@velum-labs/routekit-runtime": "0.9.6",
+    "@velum-labs/routekit-tracing": "0.9.6"
   },
   "keywords": [
     "routekit",