@velum-labs/routekit-gateway 0.17.4 → 0.18.0

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

@@ -20,6 +20,12 @@ export type PreparedResponsesReasoningInput = {
     body: unknown;
     dropped: number;
 };
+/**
+ * Repair RouteKit's legacy tool-search item prefix before replaying history to
+ * a native OpenAI Responses destination. Tool outputs correlate through
+ * `call_id`, so changing only the item `id` preserves the execution pair.
+ */
+export declare function repairLegacyToolSearchItemIds(body: unknown): unknown;
 /** Wrap provider-owned opaque reasoning without expanding the ciphertext itself. */
 export declare function wrapResponsesEncryptedContent(ciphertext: string, owner: ResponsesReasoningOwner): string;
 /** Parse a RouteKit-owned encrypted-reasoning envelope. Raw provider ciphertext is ownerless. */

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

@@ -2,9 +2,43 @@ import { createHash } from "node:crypto";
 const OPENAI_RESPONSES_CALL_ID_MAX_LENGTH = 64;
 const NORMALIZED_CALL_ID_PREFIX = "rk_";
 const ENCRYPTED_REASONING_PREFIX = "rk1.";
+const LEGACY_TOOL_SEARCH_ITEM_ID_PREFIX = "ttc_";
+const TOOL_SEARCH_ITEM_ID_PREFIX = "tsc_";
 function sameOwner(left, right) {
     return left.provider === right.provider && left.nativeModel === right.nativeModel;
 }
+/**
+ * Repair RouteKit's legacy tool-search item prefix before replaying history to
+ * a native OpenAI Responses destination. Tool outputs correlate through
+ * `call_id`, so changing only the item `id` preserves the execution pair.
+ */
+export function repairLegacyToolSearchItemIds(body) {
+    if (typeof body !== "object" || body === null || Array.isArray(body))
+        return body;
+    const record = body;
+    if (!Array.isArray(record.input))
+        return body;
+    let changed = false;
+    const input = record.input.map((candidate) => {
+        if (typeof candidate !== "object" ||
+            candidate === null ||
+            Array.isArray(candidate)) {
+            return candidate;
+        }
+        const item = candidate;
+        if (item.type !== "tool_search_call" ||
+            typeof item.id !== "string" ||
+            !item.id.startsWith(LEGACY_TOOL_SEARCH_ITEM_ID_PREFIX)) {
+            return candidate;
+        }
+        changed = true;
+        return {
+            ...item,
+            id: `${TOOL_SEARCH_ITEM_ID_PREFIX}${item.id.slice(LEGACY_TOOL_SEARCH_ITEM_ID_PREFIX.length)}`
+        };
+    });
+    return changed ? { ...record, input } : body;
+}
 /** Wrap provider-owned opaque reasoning without expanding the ciphertext itself. */
 export function wrapResponsesEncryptedContent(ciphertext, owner) {
     if (parseResponsesEncryptedContent(ciphertext) !== undefined)

package/dist/adapters/responses-stream.js

@@ -475,7 +475,7 @@ export function openAiSseToResponses(upstream, model, toolRegistry = new Map())
                         itemId: kind === "custom"
                             ? `ctc_${randomId()}`
                             : kind === "typed"
-                                ? `ttc_${randomId()}`
+                                ? `tsc_${randomId()}`
                                 : kind === "server"
                                     ? `ws_${randomId()}`
                                     : `fc_${randomId()}`,

package/dist/adapters/responses.js

@@ -15,7 +15,7 @@
 import { randomId } from "@velum-labs/routekit-runtime";
 import { attachReasoningSelection, attachReasoningSelectionError, attachResponsesReasoningMetadata, reasoningSelectionErrorOf, hasExplicitReasoningSelection, reasoningSelectionOf, routeKitRequestValidationErrorOf, responsesReasoningMetadataOf } from "./openai-chat-wire.js";
 import { droppedField } from "./dropped.js";
-import { prepareResponsesReasoningInput, wrapResponsesReasoningResponse } from "./openai-responses-wire.js";
+import { prepareResponsesReasoningInput, repairLegacyToolSearchItemIds, wrapResponsesReasoningResponse } from "./openai-responses-wire.js";
 import { unwrapUpstreamError } from "./upstream-error.js";
 import { openAiSseToResponses } from "./responses-stream.js";
 import { chatUsageToResponses } from "./responses-usage.js";
@@ -723,7 +723,7 @@ function buildOutput(message, toolRegistry) {
             if (entry.kind === "typed") {
                 output.push(typedToolCallItem({
                     name,
-                    itemId: `ttc_${randomId()}`,
+                    itemId: `tsc_${randomId()}`,
                     callId: call.id ?? `call_${randomId()}`,
                     args
                 }));
@@ -864,7 +864,7 @@ export async function handleResponses(backend, body, modelCallId, signal, backen
         destinationWireShape === "openai-responses" ||
         destinationWireShape === "routekit-envelope";
     if (supportsNativeResponses && nativeResponses !== undefined) {
-        const prepared = prepareResponsesReasoningInput(body, {
+        const prepared = prepareResponsesReasoningInput(repairLegacyToolSearchItemIds(body), {
             mode: "forward",
             owner: reasoningOwner
         });

package/dist/backend.js

@@ -1,5 +1,5 @@
 import { REASONING_SELECTION, reasoningSelectionOf, routeKitRequestValidationErrorOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
-import { normalizeOpenAiResponsesCallIds } from "./adapters/openai-responses-wire.js";
+import { normalizeOpenAiResponsesCallIds, repairLegacyToolSearchItemIds } 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;
@@ -105,7 +105,7 @@ export class OpenAiBackend {
         return fetch(joinPath(this.#baseUrl, "/responses"), {
             method: "POST",
             headers: this.#headers(options),
-            body: JSON.stringify(normalizeOpenAiResponsesCallIds(providerPayload)),
+            body: JSON.stringify(normalizeOpenAiResponsesCallIds(repairLegacyToolSearchItemIds(providerPayload))),
             ...(signal ? { signal } : {})
         });
     }

package/dist/server.js

@@ -5,7 +5,7 @@ import { effectiveModel, isStream, withDefaultModel } from "./adapters/chat.js";
 import { cursorModelVariants, isCursorChatBody, resolveCursorModelSelection, translateCursorRequest } from "./adapters/cursor.js";
 import { droppedField } from "./adapters/dropped.js";
 import { routeKitRequestValidationErrorOf, withReasoningSelection } from "./adapters/openai-chat-wire.js";
-import { prepareResponsesReasoningInput, wrapResponsesReasoningResponse } from "./adapters/openai-responses-wire.js";
+import { prepareResponsesReasoningInput, repairLegacyToolSearchItemIds, wrapResponsesReasoningResponse } from "./adapters/openai-responses-wire.js";
 import { handleResponses } from "./adapters/responses.js";
 import { validateAnthropicRequest, validateChatRequest, validateCountTokensRequest, validateResponsesRequest } from "./adapters/validate.js";
 import { authorizedRequest, parsePrincipalHeader, ROUTEKIT_PRINCIPAL_HEADER } from "./auth.js";
@@ -656,7 +656,7 @@ export async function startGateway(options) {
                 : withModel(routedBody, route.publicId);
             if (codexProviderRelay !== undefined && route?.provider === "codex") {
                 const owner = { provider: "codex", nativeModel: route.nativeId };
-                const prepared = prepareResponsesReasoningInput(withModel(body, route.nativeId), {
+                const prepared = prepareResponsesReasoningInput(repairLegacyToolSearchItemIds(withModel(body, route.nativeId)), {
                     mode: "forward",
                     owner
                 });
@@ -692,7 +692,7 @@ export async function startGateway(options) {
                     provider: "codex",
                     nativeModel: requestedModel ?? "codex/default"
                 };
-                const prepared = prepareResponsesReasoningInput(body, {
+                const prepared = prepareResponsesReasoningInput(repairLegacyToolSearchItemIds(body), {
                     mode: "forward",
                     owner
                 });

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

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 import { test } from "node:test";
-import { normalizeOpenAiResponsesCallIds, parseResponsesEncryptedContent, prepareResponsesReasoningInput, wrapResponsesEncryptedContent, wrapResponsesReasoningResponse } from "../adapters/openai-responses-wire.js";
+import { normalizeOpenAiResponsesCallIds, parseResponsesEncryptedContent, prepareResponsesReasoningInput, repairLegacyToolSearchItemIds, wrapResponsesEncryptedContent, wrapResponsesReasoningResponse } from "../adapters/openai-responses-wire.js";
 const OWNER_A = {
     provider: "codex",
     nativeModel: "gpt-5.6"
@@ -91,6 +91,49 @@ test("Responses call id replacement assignment is independent of occurrence orde
     assert.equal(forward.get(firstLongId), reversed.get(firstLongId));
     assert.equal(forward.get(secondLongId), reversed.get(secondLongId));
 });
+test("legacy tool-search item ids are repaired narrowly without mutating input", () => {
+    const legacy = {
+        type: "tool_search_call",
+        id: "ttc_legacy",
+        call_id: "call_search",
+        status: "completed"
+    };
+    const valid = {
+        type: "tool_search_call",
+        id: "tsc_valid",
+        call_id: "call_valid"
+    };
+    const unrelated = {
+        type: "function_call",
+        id: "ttc_function",
+        call_id: "call_function"
+    };
+    const output = {
+        type: "tool_search_output",
+        call_id: "call_search",
+        tools: []
+    };
+    const body = {
+        model: "gpt-5.6-sol",
+        input: [legacy, valid, unrelated, output]
+    };
+    const repaired = repairLegacyToolSearchItemIds(body);
+    assert.notEqual(repaired, body);
+    assert.notEqual(repaired.input, body.input);
+    assert.deepEqual(repaired.input[0], {
+        ...legacy,
+        id: "tsc_legacy"
+    });
+    assert.equal(repaired.input[0]?.call_id, "call_search");
+    assert.equal(repaired.input[1], valid);
+    assert.equal(repaired.input[2], unrelated);
+    assert.equal(repaired.input[3], output);
+    assert.equal(legacy.id, "ttc_legacy");
+    const alreadyCompatible = { input: [valid, output] };
+    assert.equal(repairLegacyToolSearchItemIds(alreadyCompatible), alreadyCompatible);
+    const stringInput = { input: "hello" };
+    assert.equal(repairLegacyToolSearchItemIds(stringInput), stringInput);
+});
 test("encrypted reasoning ownership round-trips exact opaque content", () => {
     const ciphertext = "opaque.with.separators/and unicode \u{1f9e0}\nbytes";
     const wrapped = wrapResponsesEncryptedContent(ciphertext, OWNER_A);

package/dist/test/responses.test.js

@@ -1586,6 +1586,8 @@ test("chatToResponses emits a native typed item for a call resolved as typed", (
     const output = response.output;
     assert.equal(output.length, 1);
     assert.equal(output[0]?.type, "tool_search_call");
+    assert.match(String(output[0]?.id), /^tsc_/);
+    assert.ok(!String(output[0]?.id).startsWith("ttc_"));
     assert.equal(output[0]?.call_id, "call_ts");
     assert.equal(output[0]?.execution, "client");
     assert.equal(output[0]?.status, "completed");
@@ -1598,16 +1600,143 @@ test("openAiSseToResponses streams a typed tool call as its native item", async
     const upstream = sseStream(chatChunk({ tool_calls: [{ index: 0, id: "call_ts", function: { name: "tool_search", arguments: args.slice(0, 10) } }] }), chatChunk({ tool_calls: [{ index: 0, function: { arguments: args.slice(10) } }] }), chatChunk({}, "tool_calls"), "data: [DONE]\n\n");
     const text = await new Response(openAiSseToResponses(upstream, "route-primary", registry)).text();
     assert.ok(text.includes('"type":"tool_search_call"'));
+    assert.ok(!text.includes('"id":"ttc_'));
     assert.ok(!text.includes('"type":"function_call"'), "typed calls never surface as function_call items");
     assert.ok(!text.includes("response.function_call_arguments"), "typed calls emit no argument delta events");
-    const completed = text.split("\n\n").find((event) => event.startsWith("event: response.completed"));
-    assert.ok(completed !== undefined);
-    const payload = JSON.parse(completed.slice(completed.indexOf("data:") + 5));
+    const events = text
+        .split("\n\n")
+        .filter((event) => event.includes("\ndata: "))
+        .map((event) => JSON.parse(event.slice(event.indexOf("data:") + 5)));
+    const added = events.find((event) => event.type === "response.output_item.added");
+    const done = events.find((event) => event.type === "response.output_item.done");
+    const completed = events.find((event) => event.type === "response.completed");
+    assert.equal(added?.item?.type, "tool_search_call");
+    assert.equal(done?.item?.type, "tool_search_call");
+    assert.match(added?.item?.id ?? "", /^tsc_/);
+    assert.equal(done?.item?.id, added?.item?.id);
+    const payload = completed;
     const item = payload.response.output.find((entry) => entry.type === "tool_search_call");
+    assert.equal(item?.id, added?.item?.id);
     assert.equal(item?.call_id, "call_ts");
     assert.equal(item?.execution, "client");
     assert.deepEqual(item?.arguments, { query: "spawn sub-agent", limit: 8 });
 });
+test("translated tool_search history keeps a valid item id when switching to native Codex", async () => {
+    const source = (sourceId) => ({
+        sourceId,
+        discoverModels: async () => [{
+                id: sourceId === "codex" ? "gpt-5.6-sol" : "claude-sonnet-4-6",
+                metadata: {
+                    architecture: {
+                        inputModalities: ["text"],
+                        outputModalities: ["text"]
+                    },
+                    supportedParameters: ["tools", "tool_choice"],
+                    provenance: "route"
+                }
+            }],
+        chat: async () => Response.json({
+            id: "chatcmpl_tool_search",
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content: null,
+                        tool_calls: [
+                            {
+                                id: "call_ts",
+                                function: {
+                                    name: "tool_search",
+                                    arguments: '{"query":"spawn sub-agent","limit":8}'
+                                }
+                            }
+                        ]
+                    },
+                    finish_reason: "tool_calls"
+                }
+            ],
+            usage: { prompt_tokens: 1, completion_tokens: 1 }
+        }),
+        embeddings: async () => Response.json({})
+    });
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { codex: {}, "claude-code": {} },
+            defaultModel: "claude-code/claude-sonnet-4-6"
+        },
+        sources: {
+            codex: source("codex"),
+            "claude-code": source("claude-code")
+        }
+    });
+    let relayedBody;
+    const relay = {
+        dialect: "codex",
+        shouldRelay: () => false,
+        relay: async (_headers, body) => {
+            relayedBody = body;
+            return Response.json({
+                id: "resp_native_after_switch",
+                object: "response",
+                status: "completed",
+                model: body.model,
+                output: [],
+                usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 }
+            });
+        }
+    };
+    const gateway = await startGateway({
+        backend,
+        providerRelays: { codex: relay }
+    });
+    try {
+        const translated = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "claude-code/claude-sonnet-4-6",
+                input: "find a sub-agent tool",
+                tools: [TOOL_SEARCH_DECL]
+            })
+        });
+        assert.equal(translated.status, 200);
+        const translatedPayload = await translated.json();
+        const toolSearchCall = translatedPayload.output.find((item) => item.type === "tool_search_call");
+        assert.ok(toolSearchCall !== undefined);
+        assert.match(String(toolSearchCall.id), /^tsc_/);
+        assert.equal(toolSearchCall.call_id, "call_ts");
+        const legacyToolSearchCall = {
+            ...toolSearchCall,
+            id: String(toolSearchCall.id).replace(/^tsc_/, "ttc_")
+        };
+        assert.match(String(legacyToolSearchCall.id), /^ttc_/);
+        const switched = await fetch(`${gateway.url()}/v1/responses`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                model: "gpt-5.6-sol",
+                input: [
+                    legacyToolSearchCall,
+                    {
+                        type: "tool_search_output",
+                        call_id: "call_ts",
+                        status: "completed",
+                        execution: "client",
+                        tools: []
+                    }
+                ]
+            })
+        });
+        assert.equal(switched.status, 200);
+        const relayedInput = relayedBody?.input;
+        assert.equal(relayedInput?.[0]?.id, toolSearchCall.id);
+        assert.equal(relayedInput?.[0]?.call_id, "call_ts");
+    }
+    finally {
+        await gateway.close();
+    }
+});
 test("openAiSseToResponses keeps function tools on the incremental function_call path", async () => {
     const upstream = sseStream(chatChunk({ tool_calls: [{ index: 0, id: "call_s", function: { name: "shell", arguments: '{"cmd":"ls"}' } }] }), chatChunk({}, "tool_calls"), "data: [DONE]\n\n");
     const text = await new Response(openAiSseToResponses(upstream, "route-primary", new Map([["apply_patch", { kind: "custom" }]]))).text();
@@ -2012,6 +2141,21 @@ test("Codex client relay still receives unknown native models after alias resolu
                     { type: "reasoning", encrypted_content: matching },
                     { type: "reasoning", encrypted_content: foreign },
                     { type: "reasoning", encrypted_content: "legacy-raw-request" },
+                    {
+                        type: "tool_search_call",
+                        id: "ttc_persisted",
+                        call_id: "call_search",
+                        status: "completed",
+                        execution: "client",
+                        arguments: { query: "verification" }
+                    },
+                    {
+                        type: "tool_search_output",
+                        call_id: "call_search",
+                        status: "completed",
+                        execution: "client",
+                        tools: []
+                    },
                     { type: "message", role: "user", content: "hi" }
                 ]
             })
@@ -2026,6 +2170,21 @@ test("Codex client relay still receives unknown native models after alias resolu
         assert.equal(relayCalls[0]?.model, "upstream-only");
         assert.deepEqual(relayCalls[0]?.input, [
             { type: "reasoning", encrypted_content: "raw-client-relay-request" },
+            {
+                type: "tool_search_call",
+                id: "tsc_persisted",
+                call_id: "call_search",
+                status: "completed",
+                execution: "client",
+                arguments: { query: "verification" }
+            },
+            {
+                type: "tool_search_output",
+                call_id: "call_search",
+                status: "completed",
+                execution: "client",
+                tools: []
+            },
             { type: "message", role: "user", content: "hi" }
         ]);
         assert.ok(!JSON.stringify(relayCalls[0]).includes("rk1."));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "0.17.4",
+  "version": "0.18.0",
   "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.17.4",
-    "@velum-labs/routekit-registry": "0.17.4",
-    "@velum-labs/routekit-runtime": "0.17.4",
-    "@velum-labs/routekit-tracing": "0.17.4"
+    "@velum-labs/routekit-contracts": "0.18.0",
+    "@velum-labs/routekit-registry": "0.18.0",
+    "@velum-labs/routekit-runtime": "0.18.0",
+    "@velum-labs/routekit-tracing": "0.18.0"
   },
   "keywords": [
     "routekit",