@velum-labs/routekit-gateway 0.16.2 → 0.16.4

package/dist/adapters/openai-responses-wire.d.ts

@@ -0,0 +1,2 @@
+/** Normalize OpenAI Responses call ids without mutating the caller's request. */
+export declare function normalizeOpenAiResponsesCallIds(body: unknown): unknown;

package/dist/adapters/openai-responses-wire.js

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+const OPENAI_RESPONSES_CALL_ID_MAX_LENGTH = 64;
+const NORMALIZED_CALL_ID_PREFIX = "rk_";
+function normalizedCallId(callId, attempt = 0) {
+    const hash = createHash("sha256").update(callId, "utf8");
+    if (attempt > 0)
+        hash.update(`\0${attempt}`, "utf8");
+    return `${NORMALIZED_CALL_ID_PREFIX}${hash.digest("base64url")}`;
+}
+/** Normalize OpenAI Responses call ids without mutating the caller's request. */
+export function normalizeOpenAiResponsesCallIds(body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return body;
+    const record = body;
+    if (!Array.isArray(record.input))
+        return body;
+    const reserved = new Set();
+    const longCallIds = new Set();
+    for (const item of record.input) {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+            continue;
+        const callId = item.call_id;
+        if (typeof callId !== "string")
+            continue;
+        if (callId.length <= OPENAI_RESPONSES_CALL_ID_MAX_LENGTH)
+            reserved.add(callId);
+        else
+            longCallIds.add(callId);
+    }
+    if (longCallIds.size === 0)
+        return body;
+    const replacements = new Map();
+    for (const callId of [...longCallIds].sort()) {
+        let attempt = 0;
+        let replacement = normalizedCallId(callId);
+        while (reserved.has(replacement)) {
+            attempt += 1;
+            replacement = normalizedCallId(callId, attempt);
+        }
+        replacements.set(callId, replacement);
+        reserved.add(replacement);
+    }
+    const input = record.input.map((item) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+            return item;
+        const callId = item.call_id;
+        if (typeof callId !== "string")
+            return item;
+        const replacement = replacements.get(callId);
+        return replacement === undefined
+            ? item
+            : { ...item, call_id: replacement };
+    });
+    return { ...record, input };
+}

package/dist/backend.js

@@ -1,4 +1,5 @@
 import { REASONING_SELECTION, reasoningSelectionOf, routeKitRequestValidationErrorOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
+import { normalizeOpenAiResponsesCallIds } from "./adapters/openai-responses-wire.js";
 /** Join a base URL (which may end in `/`) with a route path. */
 export function joinPath(baseUrl, path) {
     const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
@@ -86,10 +87,11 @@ export class OpenAiBackend {
             !Array.isArray(body)
             ? { ...body, model: this.#forceModel }
             : body;
+        const providerPayload = withoutRouteKitExtensions(routed);
         return fetch(joinPath(this.#baseUrl, "/responses"), {
             method: "POST",
             headers: this.#headers(options),
-            body: JSON.stringify(withoutRouteKitExtensions(routed)),
+            body: JSON.stringify(normalizeOpenAiResponsesCallIds(providerPayload)),
             ...(signal ? { signal } : {})
         });
     }

package/dist/provider-backends.js

@@ -1,6 +1,7 @@
 import { randomId } from "@velum-labs/routekit-runtime";
 import { joinPath } from "./backend.js";
 import { droppedField } from "./adapters/dropped.js";
+import { normalizeOpenAiResponsesCallIds } from "./adapters/openai-responses-wire.js";
 import { SseDecoder, SseParseError } from "./sse/parse.js";
 import { anthropicMessageContentOf, anthropicReasoningDetailsOf, anthropicRequestMetadataOf, attachGoogleToolCallIndexes, googleThoughtDetailsOf, googleToolCallIndexesOf, reasoningSelectionOf, routeKitRequestValidationErrorOf, attachResponsesReasoningMetadata, responsesReasoningMetadataOf } from "./adapters/openai-chat-wire.js";
 function invalidReasoningControlResponse(message, metadata = false, path) {
@@ -1027,7 +1028,7 @@ function responsesRequest(body, model, options) {
     });
     const includeEncryptedContent = responsesReasoningMetadataOf(body)?.includeEncryptedContent === true ||
         (body.messages ?? []).some((message) => responsesReasoningMetadataOf(message)?.includeEncryptedContent === true);
-    return {
+    return normalizeOpenAiResponsesCallIds({
         model,
         input,
         stream: options.forceStream || body.stream === true,
@@ -1057,7 +1058,7 @@ function responsesRequest(body, model, options) {
                     ])
             }
             : {})
-    };
+    });
 }
 function responsesOutput(payload) {
     const output = payload.output;

package/dist/server.js

@@ -1,5 +1,5 @@
 import { createServer } from "node:http";
-import { ProviderFailureError } from "@velum-labs/routekit-contracts";
+import { isCodexPickerEligibleModel, 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, parsePrincipalHeader, ROUTEKIT_PRINCIPAL_HEADER } from "./auth.js";
@@ -123,7 +123,15 @@ function withoutStaleCodexIdentity(body, route) {
 function codexPickerModels(backend, configured, native, includeUnroutedNative) {
     const nativeBySlug = new Map(native.flatMap((entry) => typeof entry.slug === "string" ? [[entry.slug, entry]] : []));
     const seen = new Set();
-    const models = configured.map((entry, priority) => {
+    const eligible = configured.filter((entry) => {
+        const route = backend.resolveModelRoute?.(entry.id);
+        return (entry.id === backend.defaultModel ||
+            isCodexPickerEligibleModel({
+                provider: route?.provider,
+                reasoning: route?.reasoning
+            }));
+    });
+    const models = eligible.map((entry, priority) => {
         const route = backend.resolveModelRoute?.(entry.id);
         const slug = route?.provider === "codex" ? route.nativeId : entry.id;
         seen.add(slug);

package/dist/test/openai-responses-wire.test.d.ts

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

package/dist/test/openai-responses-wire.test.js

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { test } from "node:test";
+import { normalizeOpenAiResponsesCallIds } from "../adapters/openai-responses-wire.js";
+test("Responses call ids are normalized deterministically without mutating input", () => {
+    const longCallId = `call_${"a".repeat(80)}`;
+    const shortCallId = "s".repeat(64);
+    const overlongBoundaryId = "l".repeat(65);
+    const call = { type: "custom_call", call_id: longCallId, name: "shell" };
+    const output = { type: "typed_call_output", call_id: longCallId, output: "done" };
+    const body = {
+        input: [
+            call,
+            output,
+            { type: "function_call", call_id: shortCallId },
+            { type: "function_call", call_id: overlongBoundaryId }
+        ]
+    };
+    const normalized = normalizeOpenAiResponsesCallIds(body);
+    const normalizedCallId = normalized.input[0]?.call_id;
+    assert.match(normalizedCallId ?? "", /^rk_[A-Za-z0-9_-]+$/);
+    assert.ok((normalizedCallId?.length ?? Infinity) <= 64);
+    assert.equal(normalized.input[1]?.call_id, normalizedCallId);
+    assert.equal(normalized.input[2]?.call_id, shortCallId);
+    assert.equal(normalized.input[2]?.call_id.length, 64);
+    assert.notEqual(normalized.input[3]?.call_id, overlongBoundaryId);
+    assert.ok((normalized.input[3]?.call_id.length ?? Infinity) <= 64);
+    assert.equal(body.input[0], call);
+    assert.equal(body.input[1], output);
+    assert.equal(call.call_id, longCallId);
+    assert.equal(output.call_id, longCallId);
+});
+test("Responses call id normalization hashes the complete id and leaves malformed input untouched", () => {
+    const prefix = "x".repeat(64);
+    const malformed = [null, "text", 7, ["nested"], { call_id: 42 }];
+    const body = {
+        input: [
+            { type: "function_call", call_id: `${prefix}a` },
+            { type: "function_call", call_id: `${prefix}b` },
+            ...malformed
+        ]
+    };
+    const normalized = normalizeOpenAiResponsesCallIds(body);
+    const first = normalized.input[0];
+    const second = normalized.input[1];
+    assert.notEqual(first.call_id, second.call_id);
+    assert.deepEqual(normalized.input.slice(2), malformed);
+});
+test("Responses call id normalization disambiguates a reserved generated ID", () => {
+    const longCallId = `call_${"collision".repeat(12)}`;
+    const preexistingCandidate = `rk_${createHash("sha256")
+        .update(longCallId, "utf8")
+        .digest("base64url")}`;
+    const body = {
+        input: [
+            { type: "function_call_output", call_id: longCallId, output: "done" },
+            { type: "function_call", call_id: preexistingCandidate, name: "reserved" },
+            { type: "function_call", call_id: longCallId, name: "actual" }
+        ]
+    };
+    const normalized = normalizeOpenAiResponsesCallIds(body);
+    const longOutputId = normalized.input[0]?.call_id;
+    const reservedId = normalized.input[1]?.call_id;
+    const longCallIdReplacement = normalized.input[2]?.call_id;
+    assert.equal(reservedId, preexistingCandidate);
+    assert.notEqual(longOutputId, reservedId);
+    assert.equal(longOutputId, longCallIdReplacement);
+    assert.ok((longOutputId?.length ?? Infinity) <= 64);
+    assert.equal(body.input[0]?.call_id, longCallId);
+    assert.equal(body.input[2]?.call_id, longCallId);
+});
+test("Responses call id replacement assignment is independent of occurrence order", () => {
+    const firstLongId = `call_${"a".repeat(80)}`;
+    const secondLongId = `call_${"b".repeat(80)}`;
+    const normalize = (ids) => {
+        const normalized = normalizeOpenAiResponsesCallIds({
+            input: ids.map((call_id) => ({ call_id }))
+        });
+        return new Map(ids.map((id, index) => [id, normalized.input[index]?.call_id]));
+    };
+    const forward = normalize([firstLongId, secondLongId]);
+    const reversed = normalize([secondLongId, firstLongId]);
+    assert.equal(forward.get(firstLongId), reversed.get(firstLongId));
+    assert.equal(forward.get(secondLongId), reversed.get(secondLongId));
+});

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

@@ -837,6 +837,61 @@ test("Google GenAI ignores malformed and unknown canonical thought metadata", as
         globalThis.fetch = original;
     }
 });
+test("OpenAI native Responses egress normalizes long paired call ids immutably", async () => {
+    const originalFetch = globalThis.fetch;
+    let outbound;
+    globalThis.fetch = async (_input, init) => {
+        outbound = JSON.parse(String(init?.body));
+        return Response.json({ id: "resp_1", output: [] });
+    };
+    try {
+        const longCallId = `call_${"native".repeat(20)}`;
+        const call = { type: "function_call", call_id: longCallId, name: "read", arguments: "{}" };
+        const output = { type: "function_call_output", call_id: longCallId, output: "source" };
+        const body = { model: "m", input: [call, output], x_routekit: { version: 1 } };
+        const backend = new OpenAiBackend({ baseUrl: "https://openai.test/v1" });
+        await backend.responses(body);
+        const items = outbound?.input;
+        assert.equal(items[0]?.call_id, items[1]?.call_id);
+        assert.ok((items[0]?.call_id.length ?? Infinity) <= 64);
+        assert.match(items[0]?.call_id ?? "", /^rk_/);
+        assert.equal(outbound?.x_routekit, undefined);
+        assert.equal(call.call_id, longCallId);
+        assert.equal(output.call_id, longCallId);
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+    }
+});
+test("Codex Responses egress normalizes long tool call and output ids together", async () => {
+    let outbound;
+    const longCallId = `call_${"codex".repeat(20)}`;
+    const backend = new CodexResponsesBackend({
+        baseUrl: "https://chatgpt.test/backend-api/codex",
+        apiKey: "oauth",
+        defaultModel: "codex-test",
+        transport: async (_url, init) => {
+            outbound = JSON.parse(String(init.body));
+            return Response.json({
+                output: [{ type: "message", content: [{ type: "output_text", text: "done" }] }]
+            });
+        }
+    });
+    await backend.chat({
+        messages: [
+            {
+                role: "assistant",
+                content: "",
+                tool_calls: [{ id: longCallId, function: { name: "read", arguments: "{}" } }]
+            },
+            { role: "tool", tool_call_id: longCallId, content: "source" }
+        ]
+    });
+    const items = outbound?.input;
+    assert.equal(items[0]?.call_id, items[1]?.call_id);
+    assert.ok((items[0]?.call_id.length ?? Infinity) <= 64);
+    assert.match(items[0]?.call_id ?? "", /^rk_/);
+});
 test("Codex Responses egress replays encrypted reasoning and include around tool continuation", async () => {
     const original = globalThis.fetch;
     let request;

package/dist/test/responses.test.js

@@ -1449,7 +1449,7 @@ test("translates a streamed Responses event sequence", async () => {
         await mock.close();
     }
 });
-test("Codex catalog advertises reasoning summaries only for text-capable wire shapes", async () => {
+test("Codex catalog filters chat-only OpenRouter models and preserves reasoning summaries", async () => {
     const source = (sourceId, wireShape) => ({
         sourceId,
         discoverModels: async () => [{
@@ -1460,15 +1460,30 @@ test("Codex catalog advertises reasoning summaries only for text-capable wire sh
                     wireShape,
                     provenance: "provider"
                 }
-            }],
+            }, ...(sourceId === "openai" ? [{ id: "unknown-model" }] : [])],
         chat: async () => Response.json({}),
         embeddings: async () => Response.json({})
     });
+    const chatOnly = {
+        sourceId: "openrouter",
+        discoverModels: async () => [{ id: "chat-only" }],
+        chat: async () => Response.json({}),
+        embeddings: async () => Response.json({})
+    };
     const backend = await CatalogBackend.create({
-        config: { providers: { openai: {}, openrouter: {} } },
+        config: {
+            providers: { openai: {}, openrouter: {} },
+            defaultModel: "openai/gpt-5.5"
+        },
         sources: {
             openai: source("openai", "openai-chat"),
-            openrouter: source("openrouter", "openrouter")
+            openrouter: {
+                ...source("openrouter", "openrouter"),
+                discoverModels: async () => [
+                    ...(await chatOnly.discoverModels()),
+                    ...(await source("openrouter", "openrouter").discoverModels())
+                ]
+            }
         }
     });
     const gateway = await startGateway({ backend });
@@ -1476,8 +1491,15 @@ test("Codex catalog advertises reasoning summaries only for text-capable wire sh
         const response = await fetch(`${gateway.url()}/v1/models`);
         assert.equal(response.status, 200);
         const catalog = (await response.json());
+        assert.deepEqual(catalog.data.map((model) => model.id), [
+            "openai/gpt-5.5",
+            "openai/unknown-model",
+            "openrouter/chat-only",
+            "openrouter/reasoning-model"
+        ]);
         assert.deepEqual(catalog.models.map((model) => [model.slug, model.supports_reasoning_summaries]), [
             ["openai/gpt-5.5", false],
+            ["openai/unknown-model", false],
             ["openrouter/reasoning-model", true]
         ]);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.16.2",
+  "version": "0.16.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -29,10 +29,10 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "zod": "4.4.3",
-    "@velum-labs/routekit-contracts": "0.16.2",
-    "@velum-labs/routekit-registry": "0.16.2",
-    "@velum-labs/routekit-runtime": "0.16.2",
-    "@velum-labs/routekit-tracing": "0.16.2"
+    "@velum-labs/routekit-contracts": "0.16.4",
+    "@velum-labs/routekit-registry": "0.16.4",
+    "@velum-labs/routekit-runtime": "0.16.4",
+    "@velum-labs/routekit-tracing": "0.16.4"
   },
   "keywords": [
     "routekit",