@velum-labs/routekit-gateway 0.17.4 → 0.18.1

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/bedrock-source.d.ts

@@ -17,6 +17,6 @@ export declare class BedrockProviderSource implements ProviderSource {
     discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
     chat(body: unknown, signal?: AbortSignal, _options?: BackendRequestOptions): Promise<Response>;
     embeddings(): Promise<Response>;
-    reasoningCapabilities(): DiscoveredModel["reasoning"];
+    reasoningCapabilities(model?: string): DiscoveredModel["reasoning"];
     close(): void;
 }

package/dist/bedrock-source.js

@@ -27,6 +27,34 @@ function activeAnthropicProfile(profile, anthropicModels) {
             return id !== undefined && anthropicModels.has(id);
         });
 }
+function isOpusFiveModel(modelId) {
+    return /(?:^|\.)anthropic\.claude-opus-5$/.test(modelId);
+}
+function inferenceProfilePriority(profileId) {
+    if (profileId.startsWith("us."))
+        return 0;
+    if (profileId.startsWith("global."))
+        return 1;
+    return 2;
+}
+function preferredInferenceProfile(current, candidate) {
+    if (current === undefined)
+        return candidate;
+    return inferenceProfilePriority(candidate) < inferenceProfilePriority(current)
+        ? candidate
+        : current;
+}
+function bedrockReasoningCapabilities(modelId) {
+    if (modelId === undefined || !isOpusFiveModel(modelId))
+        return undefined;
+    return {
+        status: "supported",
+        efforts: ["low", "medium", "high", "max"].map((id) => ({ id })),
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    };
+}
 function bedrockMetadata(model) {
     const inputModalities = (model.inputModalities ?? []).map((value) => value.toLowerCase());
     const outputModalities = (model.outputModalities ?? []).map((value) => value.toLowerCase());
@@ -43,9 +71,11 @@ function bedrockMetadata(model) {
     };
 }
 function bedrockDiscoveredModel(id, model) {
+    const reasoning = bedrockReasoningCapabilities(model.modelId);
     return {
         id,
         metadata: bedrockMetadata(model),
+        ...(reasoning !== undefined ? { reasoning } : {}),
         ...(model.responseStreamingSupported !== undefined
             ? {
                 capabilities: {
@@ -196,7 +226,15 @@ export function toBedrockConverseInput(body) {
     const selection = reasoningSelectionOf(body);
     const thinking = selection.mode === "budget"
         ? { thinking: { type: "enabled", budget_tokens: selection.budgetTokens } }
-        : undefined;
+        : isOpusFiveModel(canonical.model)
+            ? selection.mode === "effort"
+                ? { thinking: { type: "adaptive" }, output_config: { effort: selection.effort } }
+                : selection.mode === "adaptive"
+                    ? { thinking: { type: "adaptive" } }
+                    : selection.mode === "disabled"
+                        ? { thinking: { type: "disabled" } }
+                        : undefined
+            : undefined;
     const additionalModelRequestFields = thinking !== undefined || typeof canonical.top_k === "number"
         ? {
             ...thinking,
@@ -393,11 +431,13 @@ export class BedrockProviderSource {
     sourceId = "bedrock";
     #control;
     #runtime;
+    #inferenceProfilesByFoundation = new Map();
     constructor(options = {}) {
         this.#control = options.controlClient ?? new BedrockClient({});
         this.#runtime = options.runtimeClient ?? new BedrockRuntimeClient({});
     }
     async discoverModels(signal) {
+        this.#inferenceProfilesByFoundation.clear();
         const foundation = await this.#control.send(new ListFoundationModelsCommand({ byProvider: "Anthropic" }), signal === undefined ? undefined : { abortSignal: signal });
         const foundations = (foundation.modelSummaries ?? []).filter(anthropicFoundationModel);
         const byId = new Map(foundations.map((model) => [model.modelId, model]));
@@ -416,6 +456,7 @@ export class BedrockProviderSource {
                     .map((model) => foundationIdFromArn(model.modelArn))
                     .find((id) => id !== undefined && ids.has(id));
                 if (backingId !== undefined) {
+                    this.#inferenceProfilesByFoundation.set(backingId, preferredInferenceProfile(this.#inferenceProfilesByFoundation.get(backingId), profile.inferenceProfileId));
                     discovered.set(profile.inferenceProfileId, bedrockDiscoveredModel(profile.inferenceProfileId, byId.get(backingId)));
                 }
             }
@@ -437,14 +478,18 @@ export class BedrockProviderSource {
         const modelId = input.modelId;
         if (modelId === undefined)
             return errorResponse(new Error("Bedrock chat requires a model"));
+        const runtimeModelId = modelId === "anthropic.claude-opus-5"
+            ? this.#inferenceProfilesByFoundation.get(modelId) ?? modelId
+            : modelId;
+        const runtimeInput = runtimeModelId === modelId ? input : { ...input, modelId: runtimeModelId };
         try {
             if (stream) {
-                const output = await this.#runtime.send(new ConverseStreamCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+                const output = await this.#runtime.send(new ConverseStreamCommand(runtimeInput), signal === undefined ? undefined : { abortSignal: signal });
                 if (output.stream === undefined)
                     throw new Error("Bedrock returned no response stream");
                 return streamResponse(output.stream, modelId, signal);
             }
-            const output = await this.#runtime.send(new ConverseCommand(input), signal === undefined ? undefined : { abortSignal: signal });
+            const output = await this.#runtime.send(new ConverseCommand(runtimeInput), signal === undefined ? undefined : { abortSignal: signal });
             return Response.json(fromBedrockConverseOutput(output, modelId));
         }
         catch (error) {
@@ -454,7 +499,10 @@ export class BedrockProviderSource {
     embeddings() {
         return Promise.resolve(Response.json({ error: { type: "not_implemented", message: "Bedrock embeddings are not supported" } }, { status: 501 }));
     }
-    reasoningCapabilities() {
+    reasoningCapabilities(model) {
+        const known = bedrockReasoningCapabilities(model);
+        if (known !== undefined)
+            return known;
         return {
             status: "unknown",
             wireShape: "bedrock-converse",

package/dist/codex-model-selection.js

@@ -120,27 +120,37 @@ export class OpenRouterModelMetadataClient {
         }
     }
     async #refresh() {
-        const timeout = AbortSignal.timeout(this.#timeoutMs);
-        const settled = await Promise.allSettled(TASK_CATALOGS.map(async (catalog) => {
-            const response = await this.#fetch(`${this.#baseUrl}${catalog.path}`, {
-                headers: { accept: "application/json" },
-                signal: timeout
-            });
-            if (!response.ok) {
-                throw new Error(`OpenRouter ${catalog.path} returned HTTP ${response.status}`);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort(new DOMException("OpenRouter model metadata timed out", "TimeoutError"));
+        }, this.#timeoutMs);
+        const settled = await (async () => {
+            try {
+                return await Promise.allSettled(TASK_CATALOGS.map(async (catalog) => {
+                    const response = await this.#fetch(`${this.#baseUrl}${catalog.path}`, {
+                        headers: { accept: "application/json" },
+                        signal: controller.signal
+                    });
+                    if (!response.ok) {
+                        throw new Error(`OpenRouter ${catalog.path} returned HTTP ${response.status}`);
+                    }
+                    const payload = record(await response.json());
+                    if (!Array.isArray(payload?.data)) {
+                        throw new Error(`OpenRouter ${catalog.path} returned an invalid model catalog`);
+                    }
+                    return {
+                        kind: catalog.kind,
+                        entries: payload.data.flatMap((entry) => {
+                            const parsed = metadataFromEntry(entry, catalog);
+                            return parsed === undefined ? [] : [parsed];
+                        })
+                    };
+                }));
             }
-            const payload = record(await response.json());
-            if (!Array.isArray(payload?.data)) {
-                throw new Error(`OpenRouter ${catalog.path} returned an invalid model catalog`);
+            finally {
+                clearTimeout(timeout);
             }
-            return {
-                kind: catalog.kind,
-                entries: payload.data.flatMap((entry) => {
-                    const parsed = metadataFromEntry(entry, catalog);
-                    return parsed === undefined ? [] : [parsed];
-                })
-            };
-        }));
+        })();
         const responses = settled.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
         if (responses.length === 0) {
             const firstFailure = settled.find((result) => result.status === "rejected");

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/bedrock-source.test.js

@@ -20,6 +20,14 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
                                 outputModalities: ["TEXT"],
                                 responseStreamingSupported: true
                             },
+                            {
+                                modelId: "anthropic.claude-opus-5",
+                                providerName: "Anthropic",
+                                modelLifecycle: { status: "ACTIVE" },
+                                inputModalities: ["TEXT"],
+                                outputModalities: ["TEXT"],
+                                responseStreamingSupported: true
+                            },
                             { modelId: "anthropic.old", providerName: "Anthropic", modelLifecycle: { status: "LEGACY" } },
                             { modelId: "amazon.titan", providerName: "Amazon", modelLifecycle: { status: "ACTIVE" } }
                         ]
@@ -28,6 +36,7 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
                 return token === undefined ? {
                     inferenceProfileSummaries: [
                         { inferenceProfileId: "us.anthropic.claude-3", inferenceProfileName: "Claude", inferenceProfileArn: "arn:profile", status: "ACTIVE", type: "SYSTEM_DEFINED", createdAt: new Date("2026-07-09T00:00:00Z"), models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-3" }] },
+                        { inferenceProfileId: "us.anthropic.claude-opus-5", inferenceProfileName: "Opus 5", inferenceProfileArn: "arn:profile-opus-5", status: "ACTIVE", type: "SYSTEM_DEFINED", models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-opus-5" }] },
                         { inferenceProfileId: "us.amazon.titan", inferenceProfileName: "Titan", inferenceProfileArn: "arn:profile2", status: "ACTIVE", type: "SYSTEM_DEFINED", models: [{ modelArn: "arn:aws:bedrock:us-east-1::foundation-model/amazon.titan" }] }
                     ],
                     nextToken: "page-2"
@@ -42,16 +51,29 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
     });
     const discovered = await source.discoverModels();
     assert.deepEqual(discovered.map((model) => model.id), [
-        "anthropic.claude-3", "us.anthropic.claude-3", "eu.anthropic.claude-3"
+        "anthropic.claude-3",
+        "anthropic.claude-opus-5",
+        "us.anthropic.claude-3",
+        "us.anthropic.claude-opus-5",
+        "eu.anthropic.claude-3"
     ]);
     assert.deepEqual(discovered[0]?.metadata?.architecture, {
         modality: "text+image->text",
         inputModalities: ["text", "image"],
         outputModalities: ["text"]
     });
-    assert.deepEqual(discovered[1]?.metadata, discovered[0]?.metadata);
+    assert.deepEqual(discovered[2]?.metadata, discovered[0]?.metadata);
     assert.ok(discovered.every((model) => model.createdAt === undefined && model.providerPriority === undefined), "profile creation time is not model recency");
     assert.equal(discovered[0]?.capabilities?.streaming, "supported");
+    assert.equal(discovered[0]?.reasoning, undefined);
+    assert.deepEqual(discovered[1]?.reasoning, {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    });
+    assert.deepEqual(discovered[3]?.reasoning, discovered[1]?.reasoning);
     assert.equal(commands.length, 3);
 });
 test("Bedrock request translation covers system, image, tools, results, and inference config", () => {
@@ -80,6 +102,79 @@ test("Bedrock request translation covers system, image, tools, results, and infe
     assert.deepEqual(input.inferenceConfig, { maxTokens: 256, temperature: 0.2, topP: 0.9, stopSequences: ["END"] });
     assert.deepEqual(input.additionalModelRequestFields, { top_k: 40 });
 });
+test("Bedrock Opus 5 translates effort and adaptive reasoning controls", () => {
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "high"
+    }).additionalModelRequestFields, { thinking: { type: "adaptive" }, output_config: { effort: "high" } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "us.anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "adaptive" } }
+    }).additionalModelRequestFields, { thinking: { type: "adaptive" } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "budget", budgetTokens: 2048 } }
+    }).additionalModelRequestFields, { thinking: { type: "enabled", budget_tokens: 2048 } });
+    assert.deepEqual(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: [],
+        x_routekit: { version: 1, selection: { mode: "disabled" } }
+    }).additionalModelRequestFields, { thinking: { type: "disabled" } });
+    assert.equal(toBedrockConverseInput({
+        model: "anthropic.claude-opus-5",
+        messages: []
+    }).additionalModelRequestFields, undefined);
+});
+test("Bedrock maps profile-required Opus 5 foundations to a discovered inference profile", async () => {
+    let command;
+    const source = new BedrockProviderSource({
+        controlClient: {
+            send: async (value) => {
+                if (value instanceof ListFoundationModelsCommand) {
+                    return {
+                        modelSummaries: [{
+                                modelId: "anthropic.claude-opus-5",
+                                providerName: "Anthropic",
+                                modelLifecycle: { status: "ACTIVE" }
+                            }]
+                    };
+                }
+                return {
+                    inferenceProfileSummaries: [{
+                            inferenceProfileId: "us.anthropic.claude-opus-5",
+                            status: "ACTIVE",
+                            models: [{
+                                    modelArn: "arn:aws:bedrock:us-west-2::foundation-model/anthropic.claude-opus-5"
+                                }]
+                        }]
+                };
+            }
+        },
+        runtimeClient: {
+            send: async (value) => {
+                command = value;
+                return {
+                    $metadata: { requestId: "req-opus-5" },
+                    output: { message: { role: "assistant", content: [{ text: "OK" }] } },
+                    stopReason: "end_turn"
+                };
+            }
+        }
+    });
+    await source.discoverModels();
+    const response = await source.chat({
+        model: "anthropic.claude-opus-5",
+        messages: [{ role: "user", content: "Reply with exactly OK." }],
+        reasoning_effort: "low"
+    });
+    assert.equal(response.status, 200);
+    assert.equal(command instanceof ConverseCommand, true);
+    assert.equal(command?.input.modelId, "us.anthropic.claude-opus-5");
+    assert.equal((await response.json()).model, "anthropic.claude-opus-5");
+});
 test("Bedrock Converse maps text, reasoning, tools, stop, and usage", async () => {
     let command;
     const source = new BedrockProviderSource({
@@ -302,6 +397,7 @@ test("Bedrock defaults reasoning to unknown and ordinary requests omit thinking"
         controlClient: { send: async () => ({}) },
         runtimeClient: { send: async () => ({}) }
     });
+    assert.equal(source.reasoningCapabilities("anthropic.claude-opus-5")?.status, "supported");
     assert.deepEqual(source.reasoningCapabilities(), {
         status: "unknown", wireShape: "bedrock-converse", provenance: "provider"
     });

package/dist/test/codex-model-selection.test.js

@@ -215,7 +215,7 @@ test("OpenRouter metadata propagates caller cancellation and enforces its timeou
     const fetch = async (_input, init) => await new Promise((_resolve, reject) => {
         init?.signal?.addEventListener("abort", () => reject(init.signal?.reason ?? new Error("aborted")), { once: true });
     });
-    const canceled = new OpenRouterModelMetadataClient({ fetch, timeoutMs: 1_000 });
+    const canceled = new OpenRouterModelMetadataClient({ fetch, timeoutMs: 25 });
     const controller = new AbortController();
     const pending = canceled.models(controller.signal);
     controller.abort(new Error("caller canceled"));

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/dist/test/router.test.js

@@ -714,3 +714,57 @@ test("Bedrock models use canonical ids and API-key billing attribution", async (
         }
     ]);
 });
+test("Bedrock Opus 5 exposes reasoning controls and accepts routed effort selections", async () => {
+    const bodies = [];
+    const backend = await CatalogBackend.create({
+        config: {
+            providers: { bedrock: {} },
+            defaultModel: "bedrock/anthropic.claude-opus-5"
+        },
+        sources: {
+            bedrock: {
+                ...fakeSource("bedrock", [{
+                        id: "anthropic.claude-opus-5",
+                        reasoning: {
+                            status: "supported",
+                            efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+                            adaptive: true,
+                            wireShape: "bedrock-converse",
+                            provenance: "builtin"
+                        }
+                    }]),
+                async chat(body) {
+                    bodies.push(body);
+                    return Response.json({ ok: true });
+                }
+            }
+        }
+    });
+    const models = (await (await backend.models()).json());
+    assert.deepEqual(models.data[0]?.reasoning, {
+        status: "supported",
+        efforts: [{ id: "low" }, { id: "medium" }, { id: "high" }, { id: "max" }],
+        adaptive: true,
+        wireShape: "bedrock-converse",
+        provenance: "builtin"
+    });
+    const accepted = await backend.chat({
+        model: "bedrock/anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "high"
+    });
+    assert.equal(accepted.status, 200);
+    assert.equal(bodies[0]?.model, "anthropic.claude-opus-5");
+    assert.deepEqual(bodies[0]?.x_routekit, {
+        version: 1,
+        selection: { mode: "effort", effort: "high" }
+    });
+    const rejected = await backend.chat({
+        model: "bedrock/anthropic.claude-opus-5",
+        messages: [],
+        reasoning_effort: "minimal"
+    });
+    assert.equal(rejected.status, 400);
+    const error = (await rejected.json());
+    assert.equal(error.error.code, "unsupported_reasoning_control");
+});

package/package.json

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