@velum-labs/routekit-gateway 1.3.1 → 1.4.0

package/dist/adapters/responses-codec.js

@@ -34,6 +34,9 @@ function mapTextFormat(text) {
                 type: "json_schema",
                 json_schema: {
                     ...(typeof format.name === "string" ? { name: format.name } : {}),
+                    ...(typeof format.description === "string"
+                        ? { description: format.description }
+                        : {}),
                     ...(format.schema !== undefined ? { schema: format.schema } : {}),
                     ...(typeof format.strict === "boolean" ? { strict: format.strict } : {})
                 }
@@ -601,8 +604,11 @@ export function responsesToChat(body, backendModel, options = {}) {
         if (choice !== undefined)
             chat.tool_choice = choice;
     }
-    if (body.stream === true)
+    // Do not synthesize a Chat-only field when the next adapter returns to
+    // Responses; Codex reports usage in its native terminal event.
+    if (body.stream === true && options.destinationWireShape !== "openai-responses") {
         chat.stream_options = { include_usage: true };
+    }
     return chat;
 }
 // ---- non-streaming response translation ----

package/dist/http/app.js

@@ -5,6 +5,7 @@ import * as HttpEffect from "effect/unstable/http/HttpEffect";
 import { HttpServerError } from "effect/unstable/http/HttpServerError";
 import { parsePrincipalHeader, ROUTEKIT_PRINCIPAL_HEADER } from "./auth.js";
 import { gatewayErrorResponse } from "./errors.js";
+import { gatewayHealth, RUNNING_GATEWAY_VERSION } from "./health.js";
 import { NO_BODY, readJson } from "./request.js";
 import { handleModelCall, streamFetchResponse } from "../model-call-service.js";
 function jsonResponse(status, value, headers = {}) {
@@ -114,9 +115,8 @@ export function buildGatewayHttpEffect(state) {
             const request = yield* HttpServerRequest.HttpServerRequest;
             const url = new URL(request.url, "http://localhost");
             if (url.pathname === "/health") {
-                return jsonResponse(state.draining() ? 503 : 200, {
-                    status: state.draining() ? "draining" : "ok"
-                });
+                const draining = state.draining();
+                return jsonResponse(draining ? 503 : 200, gatewayHealth(draining ? "draining" : "ok", RUNNING_GATEWAY_VERSION));
             }
             if (state.draining()) {
                 return jsonResponse(503, {

package/dist/http/health.d.ts

@@ -0,0 +1,12 @@
+export type GatewayHealth = {
+    status: "ok" | "draining";
+    version: string;
+    pid?: number;
+};
+type ProcessIdentity = {
+    readonly pid: number;
+};
+/** Captured when this module loads, so later PATH or on-disk installs cannot change it. */
+export declare const RUNNING_GATEWAY_VERSION: string;
+export declare function gatewayHealth(status: GatewayHealth["status"], version: string, runningProcess?: ProcessIdentity): GatewayHealth;
+export {};

package/dist/http/health.js

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+function readRunningPackageVersion() {
+    try {
+        const manifest = JSON.parse(readFileSync(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8"));
+        return typeof manifest.version === "string" && manifest.version.length > 0
+            ? manifest.version
+            : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+/** Captured when this module loads, so later PATH or on-disk installs cannot change it. */
+export const RUNNING_GATEWAY_VERSION = readRunningPackageVersion();
+export function gatewayHealth(status, version, runningProcess = process) {
+    try {
+        const pid = runningProcess.pid;
+        return Number.isSafeInteger(pid) && pid > 0 ? { status, version, pid } : { status, version };
+    }
+    catch {
+        return { status, version };
+    }
+}

package/dist/observability/cost.js

@@ -1,4 +1,4 @@
-import { PRICING_ALIASES, DEFAULT_MODEL_PRICING as REGISTRY_MODEL_PRICING } from "@velum-labs/routekit-registry";
+import { DEFAULT_MODEL_PRICING as REGISTRY_MODEL_PRICING, attributeModelCosts, lookupModelPricing } from "@velum-labs/routekit-registry";
 import { decodeBufferedSse } from "../sse/parse.js";
 const DEFAULT_CURRENCY = "USD";
 export const DEFAULT_MODEL_PRICING = REGISTRY_MODEL_PRICING;
@@ -44,21 +44,8 @@ export function parseUsageFromSse(text) {
     }
     return usage;
 }
-function canonicalPricingKey(model) {
-    const direct = Object.keys(DEFAULT_MODEL_PRICING).find((candidate) => candidate.toLowerCase() === model.toLowerCase());
-    if (direct !== undefined)
-        return direct;
-    const alias = Object.entries(PRICING_ALIASES).find(([candidate]) => candidate.toLowerCase() === model.toLowerCase());
-    return alias?.[1] ?? model;
-}
 export function lookupPricing(model, overrides = {}) {
-    const combined = {
-        ...DEFAULT_MODEL_PRICING,
-        ...overrides
-    };
-    const key = canonicalPricingKey(model);
-    const entry = Object.entries(combined).find(([candidate]) => candidate.toLowerCase() === key.toLowerCase());
-    return entry?.[1];
+    return lookupModelPricing(model, overrides);
 }
 export function estimateCost(usage, pricing) {
     if (pricing === undefined)
@@ -67,10 +54,19 @@ export function estimateCost(usage, pricing) {
     const hasCompletion = usage.completionTokens !== undefined;
     if (!hasPrompt && !hasCompletion)
         return undefined;
+    const actuals = attributeModelCosts([
+        {
+            model: "configured",
+            usage: {
+                ...(usage.promptTokens === undefined ? {} : { inputTokens: usage.promptTokens }),
+                ...(usage.completionTokens === undefined ? {} : { outputTokens: usage.completionTokens })
+            }
+        }
+    ], { configured: pricing });
+    if (actuals.knownCostUsd === undefined)
+        return undefined;
     return {
-        costUsd: ((usage.promptTokens ?? 0) * pricing.inputPer1mTokens +
-            (usage.completionTokens ?? 0) * pricing.outputPer1mTokens) /
-            1_000_000,
+        costUsd: actuals.knownCostUsd,
         partialUsage: !hasPrompt || !hasCompletion
     };
 }

package/dist/providers/backend-core.d.ts

@@ -21,6 +21,7 @@ export type ChatMessage = {
     tool_call_id?: string;
 };
 export type ChatBody = {
+    [key: string]: unknown;
     model?: string;
     messages?: ChatMessage[];
     tools?: Array<{
@@ -40,6 +41,7 @@ export type ChatBody = {
         type?: string;
         json_schema?: {
             name?: string;
+            description?: string;
             schema?: unknown;
             strict?: boolean;
         };

package/dist/providers/codex-responses-backend.js

@@ -7,7 +7,7 @@ import { StreamPump } from "@velum-labs/routekit-runtime/sse";
 import { Effect } from "effect";
 import { routeKitRequestValidationErrorOf } from "../adapters/openai-chat-wire.js";
 import { joinPath } from "./backend.js";
-import { applyCodexForceStreamEvent, codexCompletionResponse, codexForceStreamResponse, codexReasoningModeError, codexSseToChatChunks, createCodexForceStreamState, createCodexStreamState, responsesRequest } from "./codex-responses-codec.js";
+import { applyCodexForceStreamEvent, CodexResponsesTranslationError, codexCompletionResponse, codexForceStreamResponse, codexReasoningModeError, codexSseToChatChunks, createCodexForceStreamState, createCodexStreamState, responsesRequest } from "./codex-responses-codec.js";
 import { gatewayTry, gatewayTryPromise } from "../effect/gateway.js";
 import { copyFailure, jsonResponse } from "../http/response.js";
 import { bodyRecord, HttpProviderBackend, invalidReasoningControlResponse, mapSse, providerTransport } from "./backend-core.js";
@@ -46,6 +46,22 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                     }
                 }, 400);
             }
+            const encoded = yield* gatewayTry(() => responsesRequest(body, model, {
+                forceStream: self.#forceStream,
+                omitSampling: self.#omitSampling
+            })).pipe(Effect.map((body) => ({ ok: true, body })), Effect.catch((failure) => failure.cause instanceof CodexResponsesTranslationError
+                ? Effect.succeed({ ok: false, cause: failure.cause })
+                : Effect.fail(failure)));
+            if (!encoded.ok) {
+                return jsonResponse({
+                    error: {
+                        type: "invalid_request_error",
+                        code: encoded.cause.code,
+                        param: encoded.cause.field,
+                        message: encoded.cause.message
+                    }
+                }, 400);
+            }
             const response = yield* providerTransport(self.transport, joinPath(self.baseUrl, "/responses"), {
                 method: "POST",
                 headers: {
@@ -54,10 +70,7 @@ export class CodexResponsesBackend extends HttpProviderBackend {
                     ...(self.#accountId !== undefined ? { "chatgpt-account-id": self.#accountId } : {}),
                     ...self.extraHeaders
                 },
-                body: JSON.stringify(responsesRequest(body, model, {
-                    forceStream: self.#forceStream,
-                    omitSampling: self.#omitSampling
-                })),
+                body: JSON.stringify(encoded.body),
                 ...(signal !== undefined ? { signal } : {})
             }, options);
             if (!response.ok)

package/dist/providers/codex-responses-codec.d.ts

@@ -9,6 +9,11 @@
 import { type ResponsesReasoningOwner } from "../adapters/openai-responses-wire.js";
 import { type ChatBody } from "./backend-core.js";
 import { type ProviderRecord } from "./protocol.js";
+export declare class CodexResponsesTranslationError extends Error {
+    readonly field: string;
+    readonly code = "codex_responses_unmappable_chat_field";
+    constructor(field: string, message?: string);
+}
 export declare function responsesRequest(body: ChatBody, model: string, options: {
     forceStream: boolean;
     omitSampling: boolean;

package/dist/providers/codex-responses-codec.js

@@ -13,8 +13,97 @@ import { normalizeOpenAiResponsesCallIds, prepareResponsesReasoningInput, wrapRe
 import { jsonResponse } from "../http/response.js";
 import { chatCompletion, normalizedOpenAiUsage, textContent } from "./backend-core.js";
 import { isProviderRecord, ProviderProtocolError } from "./protocol.js";
+export class CodexResponsesTranslationError extends Error {
+    field;
+    code = "codex_responses_unmappable_chat_field";
+    constructor(field, message = `Codex Responses cannot represent Chat field "${field}"`) {
+        super(message);
+        this.field = field;
+        this.name = "CodexResponsesTranslationError";
+    }
+}
+const supportedChatFields = new Set([
+    "model",
+    "messages",
+    "tools",
+    "tool_choice",
+    "parallel_tool_calls",
+    "stream",
+    "max_tokens",
+    "max_completion_tokens",
+    "temperature",
+    "top_p",
+    "reasoning_effort",
+    "response_format",
+    // RouteKit's private reasoning envelope is consumed by reasoningSelectionOf.
+    "x_routekit"
+]);
+function assertTotalChatRequest(body, options) {
+    for (const field of Object.keys(body)) {
+        if (!supportedChatFields.has(field)) {
+            throw new CodexResponsesTranslationError(field);
+        }
+    }
+    if (body.max_tokens !== undefined && body.max_completion_tokens !== undefined) {
+        throw new CodexResponsesTranslationError("max_completion_tokens", 'Codex Responses cannot represent both Chat fields "max_tokens" and "max_completion_tokens"');
+    }
+    if (options.omitSampling) {
+        for (const field of ["temperature", "top_p"]) {
+            if (body[field] !== undefined) {
+                throw new CodexResponsesTranslationError(field, `Codex subscription Responses does not support Chat field "${field}"`);
+            }
+        }
+    }
+}
+function responsesTextFormat(responseFormat) {
+    if (responseFormat === undefined)
+        return undefined;
+    switch (responseFormat.type) {
+        case "text":
+        case "json_object":
+            return { type: responseFormat.type };
+        case "json_schema": {
+            const jsonSchema = responseFormat.json_schema;
+            if (jsonSchema === undefined ||
+                typeof jsonSchema.name !== "string" ||
+                jsonSchema.name.length === 0 ||
+                jsonSchema.schema === undefined) {
+                throw new CodexResponsesTranslationError("response_format.json_schema", 'Codex Responses requires Chat "response_format.json_schema" to include name and schema');
+            }
+            return {
+                type: "json_schema",
+                name: jsonSchema.name,
+                ...(jsonSchema.description !== undefined
+                    ? { description: jsonSchema.description }
+                    : {}),
+                schema: jsonSchema.schema,
+                ...(jsonSchema.strict !== undefined ? { strict: jsonSchema.strict } : {})
+            };
+        }
+        default:
+            throw new CodexResponsesTranslationError("response_format.type", `Codex Responses cannot represent Chat response format ${JSON.stringify(responseFormat.type)}`);
+    }
+}
+function responsesToolChoice(choice) {
+    if (choice === undefined)
+        return undefined;
+    if (choice === "auto" || choice === "none" || choice === "required")
+        return choice;
+    if (!isProviderRecord(choice) || choice.type !== "function") {
+        throw new CodexResponsesTranslationError("tool_choice");
+    }
+    const fn = isProviderRecord(choice.function) ? choice.function : undefined;
+    if (typeof fn?.name !== "string" || fn.name.length === 0) {
+        throw new CodexResponsesTranslationError("tool_choice.function.name", 'Codex Responses requires a named function in Chat "tool_choice"');
+    }
+    return { type: "function", name: fn.name };
+}
 export function responsesRequest(body, model, options) {
+    assertTotalChatRequest(body, options);
     const reasoning = reasoningSelectionOf(body);
+    const textFormat = responsesTextFormat(body.response_format);
+    const toolChoice = responsesToolChoice(body.tool_choice);
+    const maxOutputTokens = body.max_completion_tokens ?? body.max_tokens;
     const input = (body.messages ?? []).flatMap((message) => {
         if (message.role === "tool") {
             return [
@@ -63,13 +152,16 @@ export function responsesRequest(body, model, options) {
         store: false,
         ...(includeEncryptedContent ? { include: ["reasoning.encrypted_content"] } : {}),
         ...(reasoning.mode === "effort" ? { reasoning: { effort: reasoning.effort } } : {}),
-        ...(!options.omitSampling && body.max_tokens !== undefined
-            ? { max_output_tokens: body.max_tokens }
-            : {}),
+        ...(maxOutputTokens !== undefined ? { max_output_tokens: maxOutputTokens } : {}),
         ...(!options.omitSampling && body.temperature !== undefined
             ? { temperature: body.temperature }
             : {}),
-        ...(body.tool_choice !== undefined ? { tool_choice: body.tool_choice } : {}),
+        ...(!options.omitSampling && body.top_p !== undefined ? { top_p: body.top_p } : {}),
+        ...(textFormat !== undefined ? { text: { format: textFormat } } : {}),
+        ...(toolChoice !== undefined ? { tool_choice: toolChoice } : {}),
+        ...(body.parallel_tool_calls !== undefined
+            ? { parallel_tool_calls: body.parallel_tool_calls }
+            : {}),
         ...(body.tools !== undefined
             ? {
                 tools: body.tools.flatMap((tool) => tool.function === undefined
@@ -79,7 +171,10 @@ export function responsesRequest(body, model, options) {
                             type: "function",
                             name: tool.function.name,
                             description: tool.function.description,
-                            parameters: tool.function.parameters ?? { type: "object" }
+                            parameters: tool.function.parameters ?? { type: "object" },
+                            ...(typeof tool.function.strict === "boolean"
+                                ? { strict: tool.function.strict }
+                                : {})
                         }
                     ])
             }

package/dist/switching-proxy.d.ts

@@ -22,6 +22,8 @@ export type SwitchingGatewayProxy = {
 };
 export type SwitchingGatewayProxyOptions = {
     target: string;
+    /** Running daemon package version captured by its loaded module. */
+    packageVersion?: string;
     host?: string;
     port?: number;
     authToken?: string;

package/dist/switching-proxy.js

@@ -10,12 +10,13 @@
 import { createServer } from "node:http";
 import { EVAL_ATTRIBUTION_HEADER, EVAL_POLICY_BYPASS_HEADER, isForbiddenEvalModel } from "@velum-labs/routekit-eval-contracts";
 import { assertAuthenticatedBind, trimTrailingSlashes } from "@velum-labs/routekit-runtime/network";
-import { createNodeHttpHandlerEffect, executeWebRequest, RouteKitLive, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
+import { createNodeHttpHandlerEffect, executeWebRequest, RouteKitFailure, RouteKitLive, toRouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { Context, Deferred, Effect, Layer, ManagedRuntime, Stream } from "effect";
 import { HttpClient, HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
 import * as HttpEffect from "effect/unstable/http/HttpEffect";
 import { authorizedRequest, ROUTEKIT_PRINCIPAL_HEADER, resolvePrincipal } from "./http/auth.js";
 import { gatewayTryPromise } from "./effect/gateway.js";
+import { gatewayHealth, RUNNING_GATEWAY_VERSION } from "./http/health.js";
 const MAX_BODY_BYTES = 16 * 1024 * 1024;
 const DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS = 10 * 60 * 1000;
 const HOP_BY_HOP = new Set([
@@ -182,6 +183,7 @@ const startSwitchingGatewayProxyOperation = Effect.fn("SwitchingGatewayProxy.sta
     let draining = false;
     let retiring = false;
     let inflight = 0;
+    const healthVersion = input.packageVersion ?? RUNNING_GATEWAY_VERSION;
     const httpEffect = yield* Effect.gen(function* () {
         const router = yield* HttpRouter.make;
         const httpClient = yield* HttpClient.HttpClient;
@@ -222,14 +224,18 @@ const startSwitchingGatewayProxyOperation = Effect.fn("SwitchingGatewayProxy.sta
                         error: { message: rejection.message, type: "invalid_request_error" }
                     });
                 }
-                const headersTimeout = new AbortController();
-                const timeout = setTimeout(() => headersTimeout.abort(new Error(`gateway generation did not return headers within ${input.upstreamHeadersTimeoutMs ?? DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS}ms`)), input.upstreamHeadersTimeoutMs ?? DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS);
+                const timeoutMs = input.upstreamHeadersTimeoutMs ?? DEFAULT_UPSTREAM_HEADERS_TIMEOUT_MS;
                 const upstream = yield* executeWebRequest(`${selected.url}${path}`, {
                     method: nodeReq.method ?? "GET",
                     headers: requestHeaders(nodeReq.headers, principal),
                     ...(body !== undefined ? { body } : {}),
-                    signal: AbortSignal.any([aborter.signal, headersTimeout.signal])
-                }).pipe(Effect.ensuring(Effect.sync(() => clearTimeout(timeout))));
+                    signal: aborter.signal
+                }).pipe(Effect.timeoutOrElse({
+                    duration: timeoutMs,
+                    orElse: () => Effect.fail(new RouteKitFailure({
+                        message: `gateway generation did not return headers within ${timeoutMs}ms`
+                    }))
+                }));
                 return HttpEffect.scopeTransferToStream(proxyResponse(upstream, retiring));
             }).pipe(Effect.orElseSucceed(() => jsonResponse(502, {
                 error: { message: "router generation unavailable", type: "upstream_error" }
@@ -243,9 +249,7 @@ const startSwitchingGatewayProxyOperation = Effect.fn("SwitchingGatewayProxy.sta
             const request = yield* HttpServerRequest.HttpServerRequest;
             const path = new URL(request.url, "http://localhost").pathname;
             if (path === "/health") {
-                return jsonResponse(draining ? 503 : 200, {
-                    status: draining ? "draining" : "ok"
-                });
+                return jsonResponse(draining ? 503 : 200, gatewayHealth(draining ? "draining" : "ok", healthVersion));
             }
             if (draining) {
                 return jsonResponse(503, {

package/dist/test/cost.test.js

@@ -12,6 +12,7 @@ test("single-call metering normalizes provider usage and registry pricing", () =
         outputPer1mTokens: 10
     });
     assert.deepEqual(estimateCost({ promptTokens: 1_000_000, completionTokens: 1_000_000 }, lookupPricing("gpt-5.5")), { costUsd: 11.25, partialUsage: false });
+    assert.equal(estimateCost({ promptTokens: 1_000_000 }, lookupPricing("gpt-5.5")), undefined);
 });
 test("SSE usage extraction retains the last provider usage block", () => {
     const text = `data: ${JSON.stringify({ choices: [{ delta: { content: "first" } }] })}\n\n` +

package/dist/test/drain.test.js

@@ -4,6 +4,7 @@ import { RouteKitFailure, runRouteKitEffect } from "@velum-labs/routekit-runtime
 import { Effect } from "effect";
 import { borrowedBackendPorts, staticBackendModelPort } from "../providers/backend.js";
 import { startGateway } from "../gateway-service.js";
+import { RUNNING_GATEWAY_VERSION } from "../http/health.js";
 /**
  * Graceful drain: a draining gateway must report unhealthy and reject new
  * model calls while letting in-flight requests (long-lived LLM streams)
@@ -50,7 +51,11 @@ test("drain finishes in-flight streams, rejects new work, and flips /health to 5
         // Health flips to 503 so probes stop routing new work here.
         const health = await fetch(`${gateway.url()}/health`);
         assert.equal(health.status, 503);
-        assert.deepEqual(await health.json(), { status: "draining" });
+        assert.deepEqual(await health.json(), {
+            status: "draining",
+            version: RUNNING_GATEWAY_VERSION,
+            pid: process.pid
+        });
         // New model calls are rejected while draining.
         const rejected = await fetch(`${gateway.url()}/v1/chat/completions`, {
             method: "POST",

package/dist/test/health.test.d.ts

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

package/dist/test/health.test.js

@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { gatewayHealth } from "../http/health.js";
+test("health keeps version and omits pid when process identity lookup fails", () => {
+    const unavailablePid = {
+        get pid() {
+            throw new Error("pid unavailable");
+        }
+    };
+    assert.deepEqual(gatewayHealth("ok", "1.2.3", unavailablePid), {
+        status: "ok",
+        version: "1.2.3"
+    });
+});

package/dist/test/provider-google-codex.test.js

@@ -1,11 +1,18 @@
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
 import { test } from "node:test";
-import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { RouteKitLive, runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
+import { Effect } from "effect";
 import { responsesReasoningMetadataOf } from "../adapters/openai-chat-wire.js";
 import { parseResponsesEncryptedContent, wrapResponsesEncryptedContent } from "../adapters/openai-responses-wire.js";
 import { responsesToChat } from "../adapters/responses.js";
 import { OpenAiBackend } from "../providers/openai-backend.js";
 import { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "../providers/backends.js";
+import { languageModelDimensionRequestDecomposerLayer } from "../routing/dimension-request-decomposer.js";
+import { classifierResponseSchemaV3 } from "../routing/classifier-v3-protocol.js";
+import { lunaDirectRequestDecomposerLayer } from "../routing/luna-direct-classifier.js";
+import { buildTaskContextV3 } from "../routing/task-context.js";
+import { RequestDecomposer } from "../services/request-decomposer/service.js";
 import { ChatStreamAssembler } from "../sse/chat-assembler.js";
 import { SseDecoder } from "../sse/parse.js";
 import { asTransport, sse } from "./provider-backends-fixtures.js";
@@ -439,6 +446,220 @@ test("Codex Responses egress preserves subscription auth and tool output", async
         globalThis.fetch = original;
     }
 });
+test("dimension classifier reaches Codex Responses with its exact schema and output budget", async () => {
+    const original = globalThis.fetch;
+    let request;
+    const dimensions = [
+        ["provider-adapters", "Provider-specific protocol adapters"],
+        ["eval-routing", "Evaluation-driven model routing"],
+        ["gateway-protocol", "OpenAI-compatible gateway protocol behavior"],
+        ["daemon-lifecycle", "Daemon startup and lifecycle"],
+        ["remote-enrollment", "Remote enrollment and control relays"]
+    ].map(([id, description]) => ({
+        id: id,
+        description: description,
+        includes: [`${description} work`],
+        excludes: [`work outside ${description.toLowerCase()}`]
+    }));
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return sse([
+            {
+                event: "response.completed",
+                data: {
+                    response: {
+                        output: [
+                            {
+                                type: "message",
+                                content: [
+                                    {
+                                        type: "output_text",
+                                        text: '{"weights":{"provider-adapters":1,"eval-routing":0,"gateway-protocol":0,"daemon-lifecycle":0,"remote-enrollment":0},"unknownWeight":0}'
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            }
+        ]);
+    };
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "codex-test",
+            forceStream: true,
+            omitSampling: true
+        });
+        const classifier = await runRouteKitEffect(RequestDecomposer.pipe(Effect.provide(languageModelDimensionRequestDecomposerLayer({
+            model: "codex/gpt-5.6-luna",
+            complete: (body, signal) => backend.chat(body, signal).pipe(Effect.provide(RouteKitLive))
+        }))));
+        const result = await runRouteKitEffect(classifier.decompose({
+            request: "Repair the Codex Responses adapter",
+            dimensions
+        }));
+        assert.deepEqual(result, {
+            weights: dimensions.map((dimension) => ({
+                dimensionId: dimension.id,
+                weight: dimension.id === "provider-adapters" ? 1 : 0
+            })),
+            unknownWeight: 0
+        });
+        const outbound = (await request?.json());
+        assert.equal(outbound.max_output_tokens, 256);
+        assert.equal(outbound.text?.format?.type, "json_schema");
+        assert.equal(outbound.text?.format?.name, "routekit_request_decomposition");
+        assert.equal(outbound.text?.format?.strict, true);
+        assert.equal(outbound.text?.format?.schema?.additionalProperties, false);
+        assert.deepEqual(outbound.text?.format?.schema?.properties?.weights?.required, [
+            "provider-adapters",
+            "eval-routing",
+            "gateway-protocol",
+            "daemon-lifecycle",
+            "remote-enrollment"
+        ]);
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("V3 classifier reaches Codex Responses with its exact schema and output budget", async () => {
+    const original = globalThis.fetch;
+    let request;
+    const basis = JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/routing-basis-v3.example.json", import.meta.url), "utf8"));
+    const activation = JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/published-routing-activation-v3.example.json", import.meta.url), "utf8"));
+    const scores = Object.fromEntries(basis.dimensions.map((dimension) => [dimension.id, 0]));
+    globalThis.fetch = async (input, init) => {
+        request = new Request(input, init);
+        return sse([
+            {
+                event: "response.completed",
+                data: {
+                    response: {
+                        output: [
+                            {
+                                type: "message",
+                                content: [
+                                    {
+                                        type: "output_text",
+                                        text: JSON.stringify({
+                                            dimension_scores: scores,
+                                            unknown_probability: 0
+                                        })
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                }
+            }
+        ]);
+    };
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "codex-test",
+            forceStream: true,
+            omitSampling: true
+        });
+        const classifier = await runRouteKitEffect(RequestDecomposer.pipe(Effect.provide(lunaDirectRequestDecomposerLayer({
+            model: "codex/gpt-5.6-luna",
+            modelAvailable: () => true,
+            complete: (body, signal) => backend.chat(body, signal).pipe(Effect.provide(RouteKitLive))
+        }))));
+        const context = buildTaskContextV3({
+            currentRequest: "Repair the Codex Responses adapter",
+            earlierUserContext: [],
+            relevantDiagnostics: []
+        }, basis.facetSnapshot, activation.classifier.context);
+        const result = await runRouteKitEffect(classifier.classify({
+            basis,
+            context,
+            config: activation.classifier
+        }));
+        assert.deepEqual(result.scores, basis.dimensions.map((dimension) => ({ dimensionId: dimension.id, score: 0 })));
+        const outbound = (await request?.json());
+        assert.equal(outbound.max_output_tokens, activation.classifier.maxCompletionTokens);
+        assert.deepEqual(outbound.text?.format, {
+            type: "json_schema",
+            name: "routekit_independent_dimension_scores_v3",
+            strict: true,
+            schema: classifierResponseSchemaV3(basis)
+        });
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription egress named-rejects an unmappable Chat field before I/O", async () => {
+    const original = globalThis.fetch;
+    let requests = 0;
+    globalThis.fetch = async () => {
+        requests += 1;
+        return Response.json({});
+    };
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "codex-test",
+            forceStream: true,
+            omitSampling: true
+        });
+        const response = await runRouteKitEffect(backend.chat({
+            messages: [{ role: "user", content: "reply" }],
+            top_k: 40
+        }));
+        const payload = (await response.json());
+        assert.equal(response.status, 400);
+        assert.equal(requests, 0);
+        assert.deepEqual(payload.error, {
+            type: "invalid_request_error",
+            code: "codex_responses_unmappable_chat_field",
+            param: "top_k",
+            message: 'Codex Responses cannot represent Chat field "top_k"'
+        });
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
+test("Codex subscription egress named-rejects an unknown Chat field before I/O", async () => {
+    const original = globalThis.fetch;
+    let requests = 0;
+    globalThis.fetch = async () => {
+        requests += 1;
+        return Response.json({});
+    };
+    try {
+        const backend = new CodexResponsesBackend({
+            baseUrl: "https://chatgpt.test/backend-api/codex",
+            apiKey: "oauth",
+            defaultModel: "codex-test",
+            forceStream: true,
+            omitSampling: true
+        });
+        const response = await runRouteKitEffect(backend.chat({
+            messages: [{ role: "user", content: "reply" }],
+            best_of: 2
+        }));
+        const payload = (await response.json());
+        assert.equal(response.status, 400);
+        assert.equal(requests, 0);
+        assert.deepEqual(payload.error, {
+            type: "invalid_request_error",
+            code: "codex_responses_unmappable_chat_field",
+            param: "best_of",
+            message: 'Codex Responses cannot represent Chat field "best_of"'
+        });
+    }
+    finally {
+        globalThis.fetch = original;
+    }
+});
 test("Codex subscription egress forces SSE and omits unsupported sampling", async () => {
     const original = globalThis.fetch;
     let request;
@@ -471,8 +692,6 @@ test("Codex subscription egress forces SSE and omits unsupported sampling", asyn
         });
         const response = await runRouteKitEffect(backend.chat({
             stream: false,
-            max_tokens: 16,
-            temperature: 0,
             messages: [{ role: "user", content: "reply" }]
         }));
         const outbound = (await request?.json());

package/dist/test/responses-conversion.test.js

@@ -132,6 +132,34 @@ test("responsesToChat tolerates reasoning: null and text: null (Codex custom-pro
     assert.equal(chat.model, "grok-4");
     assert.equal(chat.reasoning_effort, undefined);
     assert.equal(chat.response_format, undefined);
+    assert.deepEqual(chat.stream_options, { include_usage: true });
+});
+test("responsesToChat does not add Chat stream options before Codex Responses egress", () => {
+    const chat = responsesToChat({
+        model: "codex/matrix-codex",
+        input: [
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: "Use the declared tool." }]
+            }
+        ],
+        stream: true,
+        tools: [
+            {
+                type: "function",
+                name: "read_file",
+                description: "read a file",
+                parameters: {
+                    type: "object",
+                    properties: { path: { type: "string" } }
+                }
+            }
+        ]
+    }, "matrix-codex", { destinationWireShape: "openai-responses" });
+    assert.equal(chat.stream, true);
+    assert.equal(chat.stream_options, undefined);
+    assert.equal((chat.tools[0]?.function?.name), "read_file");
 });
 test("responsesToChat treats Codex reasoning effort null as absent", () => {
     const chat = responsesToChat({ model: "gpt-5.5", input: "say OK", reasoning: { effort: null } }, "gpt-5.5");

package/dist/test/responses-reasoning.test.js

@@ -839,6 +839,69 @@ test("Responses follows ModelRoutedBackend reasoning wire capability", async ()
         await Effect.runPromise(gateway.close);
     }
 });
+test("streaming Responses requests reach Codex without Chat-only stream options", async () => {
+    let codexBody;
+    const codex = new CodexResponsesBackend({
+        baseUrl: "https://codex.test",
+        apiKey: "x",
+        defaultModel: "codex-native",
+        transport: asTransport(async (_url, init) => {
+            codexBody = JSON.parse(String(init.body));
+            return new Response([
+                'event: response.output_text.delta\ndata: {"type":"response.output_text.delta","delta":"ok"}\n\n',
+                'event: response.completed\ndata: {"type":"response.completed","response":{"output":[{"type":"message","content":[{"type":"output_text","text":"ok"}]}]}}\n\n'
+            ].join(""), { headers: { "content-type": "text/event-stream" } });
+        })
+    });
+    const primary = {
+        defaultModel: "primary-model",
+        ports: borrowedBackendPorts("primary-model"),
+        chat: () => Effect.succeed(Response.json({ choices: [] })),
+        models: () => Effect.succeed(Response.json({ data: [] })),
+        embeddings: () => Effect.succeed(Response.json({}))
+    };
+    const backend = new ModelRoutedBackend({
+        routedModelIds: ["codex-model"],
+        routed: codex,
+        primary
+    });
+    const gateway = await startGateway({ backend });
+    try {
+        const response = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "codex-model",
+                input: [
+                    {
+                        type: "message",
+                        role: "user",
+                        content: [{ type: "input_text", text: "Use the declared tool." }]
+                    }
+                ],
+                stream: true,
+                tools: [
+                    {
+                        type: "function",
+                        name: "read_file",
+                        description: "read a file",
+                        parameters: {
+                            type: "object",
+                            properties: { path: { type: "string" } }
+                        }
+                    }
+                ]
+            })
+        });
+        assert.equal(response.status, 200, await response.clone().text());
+        assert.equal(codexBody?.stream, true);
+        assert.equal("stream_options" in (codexBody ?? {}), false);
+        assert.equal(codexBody?.tools?.[0]?.name, "read_file");
+    }
+    finally {
+        await Effect.runPromise(gateway.close);
+    }
+});
 test("native Responses swaps isolate provider reasoning and restore it on A to B to A", async () => {
     const requests = [];
     const routes = {

package/dist/test/server-resilience.test.js

@@ -9,6 +9,7 @@ import { borrowedBackendPorts } from "../providers/backend.js";
 import { OpenAiBackend } from "../providers/openai-backend.js";
 import { startGateway } from "../gateway-service.js";
 import { startSwitchingGatewayProxy } from "../switching-proxy.js";
+import { RUNNING_GATEWAY_VERSION } from "../http/health.js";
 /**
  * Crash resilience: an upstream stream that dies mid-response (the shape of a
  * local model server being OOM-killed during a turn) must fail only that one
@@ -90,6 +91,11 @@ test("a mid-stream upstream failure does not kill the gateway process", async ()
         // The gateway (and its hosting process) is still alive and serving.
         const health = await fetch(`${gateway.url()}/health`);
         assert.equal(health.status, 200);
+        assert.deepEqual(await health.json(), {
+            status: "ok",
+            version: RUNNING_GATEWAY_VERSION,
+            pid: process.pid
+        });
         const models = await fetch(`${gateway.url()}/v1/models`);
         assert.equal(models.status, 200);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "1.3.1",
+  "version": "1.4.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -45,12 +45,12 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-config-core": "1.3.1",
-    "@velum-labs/routekit-contracts": "1.3.1",
-    "@velum-labs/routekit-eval-contracts": "1.3.1",
-    "@velum-labs/routekit-eval-core": "1.3.1",
-    "@velum-labs/routekit-registry": "1.3.1",
-    "@velum-labs/routekit-runtime": "1.3.1"
+    "@velum-labs/routekit-config-core": "1.4.0",
+    "@velum-labs/routekit-contracts": "1.4.0",
+    "@velum-labs/routekit-eval-contracts": "1.4.0",
+    "@velum-labs/routekit-eval-core": "1.4.0",
+    "@velum-labs/routekit-registry": "1.4.0",
+    "@velum-labs/routekit-runtime": "1.4.0"
   },
   "keywords": [
     "routekit",