@velum-labs/routekit-gateway 0.18.0 → 0.18.1

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/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/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.18.0",
+  "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.18.0",
-    "@velum-labs/routekit-registry": "0.18.0",
-    "@velum-labs/routekit-runtime": "0.18.0",
-    "@velum-labs/routekit-tracing": "0.18.0"
+    "@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",