@velum-labs/routekit-gateway 0.18.1 → 0.18.3

package/dist/backend.d.ts

@@ -44,8 +44,8 @@ export type Backend = {
     resolveModelRoute?(requested: string | undefined, nativeProvider?: string): BackendModelRoute | undefined;
     /**
      * Whether the backend serves this exact model id itself. Unlike
-     * {@link resolveModel} — which folds unknown
-     * ids into the default — this distinguishes "mine" from "unknown", so the
+     * The defaulting resolver folds unknown ids into the default; this
+     * distinguishes "mine" from "unknown", so the
      * gateway can hand unknown ids to a relay (e.g. the Codex backend relay)
      * instead of silently routing them to the default.
      */

package/dist/bedrock-source.d.ts

@@ -1,13 +1,18 @@
 import { BedrockClient } from "@aws-sdk/client-bedrock";
 import { BedrockRuntimeClient, type ConverseCommandInput, type ConverseCommandOutput } from "@aws-sdk/client-bedrock-runtime";
-import type { BackendRequestOptions } from "./backend.js";
+import { OpenAiBackend, type BackendRequestOptions } from "./backend.js";
 import type { DiscoveredModel, ProviderSource } from "./provider-source.js";
 export type BedrockControlClient = Pick<BedrockClient, "send">;
 export type BedrockRuntime = Pick<BedrockRuntimeClient, "send">;
+export type BedrockMantleBackend = Pick<OpenAiBackend, "chat" | "responses">;
 export type BedrockProviderSourceOptions = {
     controlClient?: BedrockControlClient;
     runtimeClient?: BedrockRuntime;
+    env?: NodeJS.ProcessEnv;
+    mantleBackend?: BedrockMantleBackend;
 };
+export declare const BEDROCK_OPENAI_ALLOWLIST: readonly ["openai.gpt-5.4", "openai.gpt-5.5", "openai.gpt-5.6-sol", "openai.gpt-5.6-terra", "openai.gpt-5.6-luna"];
+export declare function isBedrockOpenAiModel(modelId: string): boolean;
 export declare function toBedrockConverseInput(body: unknown): ConverseCommandInput;
 export declare function fromBedrockConverseOutput(output: ConverseCommandOutput, model: string): Record<string, unknown>;
 export declare class BedrockProviderSource implements ProviderSource {
@@ -15,7 +20,9 @@ export declare class BedrockProviderSource implements ProviderSource {
     readonly sourceId: "bedrock";
     constructor(options?: BedrockProviderSourceOptions);
     discoverModels(signal?: AbortSignal): Promise<readonly DiscoveredModel[]>;
-    chat(body: unknown, signal?: AbortSignal, _options?: BackendRequestOptions): Promise<Response>;
+    supportsResponses(model: string): boolean;
+    responses(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
+    chat(body: unknown, signal?: AbortSignal, options?: BackendRequestOptions): Promise<Response>;
     embeddings(): Promise<Response>;
     reasoningCapabilities(model?: string): DiscoveredModel["reasoning"];
     close(): void;

package/dist/bedrock-source.js

@@ -1,7 +1,74 @@
 import { BedrockClient, ListFoundationModelsCommand, ListInferenceProfilesCommand } from "@aws-sdk/client-bedrock";
 import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
 import { randomId } from "@velum-labs/routekit-runtime";
+import { OpenAiBackend } from "./backend.js";
 import { anthropicReasoningDetailsOf, reasoningSelectionOf, withoutRouteKitExtensions } from "./adapters/openai-chat-wire.js";
+export const BEDROCK_OPENAI_ALLOWLIST = [
+    "openai.gpt-5.4",
+    "openai.gpt-5.5",
+    "openai.gpt-5.6-sol",
+    "openai.gpt-5.6-terra",
+    "openai.gpt-5.6-luna"
+];
+const BEDROCK_OPENAI_MODEL = /^(?:(?:us|eu|global)\.)?openai\.gpt-/;
+export function isBedrockOpenAiModel(modelId) {
+    return BEDROCK_OPENAI_MODEL.test(modelId);
+}
+function mantleApiKey(env) {
+    const key = env.AWS_BEARER_TOKEN_BEDROCK ?? env.BEDROCK_API_KEY;
+    return typeof key === "string" && key.length > 0 ? key : undefined;
+}
+function mantleRegion(env) {
+    const region = env.AWS_REGION ?? env.AWS_DEFAULT_REGION;
+    return typeof region === "string" && region.length > 0 ? region : undefined;
+}
+function mantleBaseUrl(region) {
+    return `https://bedrock-mantle.${region}.api.aws/openai/v1`;
+}
+function bedrockOpenAiNativeId(modelId) {
+    return modelId.replace(/^(?:us|eu|global)\./, "");
+}
+function bedrockOpenAiReasoning(modelId) {
+    const native = bedrockOpenAiNativeId(modelId).replace(/^openai\./, "");
+    if (/^gpt-5\.6(?:-(?:sol|terra|luna))?(?:-\d{4}-\d{2}-\d{2})?$/.test(native)) {
+        return {
+            status: "supported",
+            efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+            defaultEffort: "medium",
+            wireShape: "openai-responses",
+            provenance: "builtin"
+        };
+    }
+    if (/^gpt-5\.(?:4|5)(?:-\d{4}-\d{2}-\d{2})?$/.test(native)) {
+        return {
+            status: "supported",
+            efforts: ["none", "low", "medium", "high", "xhigh"].map((id) => ({ id })),
+            wireShape: "openai-responses",
+            provenance: "builtin"
+        };
+    }
+    return {
+        status: "supported",
+        wireShape: "openai-responses",
+        provenance: "builtin"
+    };
+}
+function bedrockOpenAiDiscoveredModel(id) {
+    return {
+        id,
+        metadata: {
+            architecture: {
+                modality: "text+image->text",
+                inputModalities: ["text", "image"],
+                outputModalities: ["text"]
+            },
+            supportedParameters: ["tools", "tool_choice"],
+            provenance: "route"
+        },
+        reasoning: bedrockOpenAiReasoning(id),
+        capabilities: { streaming: "supported" }
+    };
+}
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
@@ -431,42 +498,106 @@ export class BedrockProviderSource {
     sourceId = "bedrock";
     #control;
     #runtime;
+    #env;
+    #injectedMantle;
+    #mantle;
     #inferenceProfilesByFoundation = new Map();
     constructor(options = {}) {
         this.#control = options.controlClient ?? new BedrockClient({});
         this.#runtime = options.runtimeClient ?? new BedrockRuntimeClient({});
+        this.#env = options.env ?? process.env;
+        this.#injectedMantle = options.mantleBackend;
+    }
+    #mantleBackend() {
+        if (this.#injectedMantle !== undefined)
+            return this.#injectedMantle;
+        if (this.#mantle !== undefined)
+            return this.#mantle;
+        const apiKey = mantleApiKey(this.#env);
+        const region = mantleRegion(this.#env);
+        if (apiKey === undefined || region === undefined)
+            return undefined;
+        this.#mantle = new OpenAiBackend({
+            baseUrl: mantleBaseUrl(region),
+            apiKey
+        });
+        return this.#mantle;
+    }
+    #missingMantleResponse() {
+        return Response.json({
+            error: {
+                type: "invalid_request_error",
+                message: "Bedrock OpenAI models require AWS_BEARER_TOKEN_BEDROCK and AWS_REGION"
+            }
+        }, { status: 400 });
     }
     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]));
-        const ids = new Set(byId.keys());
-        const discovered = new Map(foundations.map((model) => [
-            model.modelId,
-            bedrockDiscoveredModel(model.modelId, model)
-        ]));
-        let nextToken;
-        do {
-            const profiles = await this.#control.send(new ListInferenceProfilesCommand({ ...(nextToken !== undefined ? { nextToken } : {}) }), signal === undefined ? undefined : { abortSignal: signal });
-            for (const profile of profiles.inferenceProfileSummaries ?? []) {
-                if (!activeAnthropicProfile(profile, ids))
-                    continue;
-                const backingId = (profile.models ?? [])
-                    .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)));
+        const abort = signal === undefined ? undefined : { abortSignal: signal };
+        let discovered = new Map();
+        try {
+            const foundation = await this.#control.send(new ListFoundationModelsCommand({ byProvider: "Anthropic" }), abort);
+            const foundations = (foundation.modelSummaries ?? []).filter(anthropicFoundationModel);
+            const byId = new Map(foundations.map((model) => [model.modelId, model]));
+            const ids = new Set(byId.keys());
+            discovered = new Map(foundations.map((model) => [
+                model.modelId,
+                bedrockDiscoveredModel(model.modelId, model)
+            ]));
+            let nextToken;
+            do {
+                const profiles = await this.#control.send(new ListInferenceProfilesCommand({ ...(nextToken !== undefined ? { nextToken } : {}) }), abort);
+                for (const profile of profiles.inferenceProfileSummaries ?? []) {
+                    if (!activeAnthropicProfile(profile, ids))
+                        continue;
+                    const backingId = (profile.models ?? [])
+                        .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)));
+                    }
                 }
+                nextToken = profiles.nextToken;
+            } while (nextToken !== undefined && nextToken.length > 0);
+        }
+        catch (error) {
+            if (mantleApiKey(this.#env) === undefined)
+                throw error;
+            discovered = new Map();
+            this.#inferenceProfilesByFoundation.clear();
+        }
+        if (mantleApiKey(this.#env) !== undefined) {
+            for (const id of BEDROCK_OPENAI_ALLOWLIST) {
+                discovered.set(id, bedrockOpenAiDiscoveredModel(id));
             }
-            nextToken = profiles.nextToken;
-        } while (nextToken !== undefined && nextToken.length > 0);
+        }
         if (discovered.size === 0)
             throw new Error("model discovery returned no active Anthropic Bedrock models");
         return [...discovered.values()];
     }
-    async chat(body, signal, _options) {
+    supportsResponses(model) {
+        return isBedrockOpenAiModel(model);
+    }
+    async responses(body, signal, options) {
+        const requestedModel = record(body)?.model;
+        const model = typeof requestedModel === "string" ? requestedModel : "";
+        if (!isBedrockOpenAiModel(model)) {
+            return Response.json({ error: { type: "not_supported", message: "native Responses egress is not supported" } }, { status: 501 });
+        }
+        const backend = this.#mantleBackend();
+        if (backend === undefined)
+            return this.#missingMantleResponse();
+        return backend.responses(body, signal, options);
+    }
+    async chat(body, signal, options) {
+        const requestedModel = record(body)?.model;
+        if (typeof requestedModel === "string" && isBedrockOpenAiModel(requestedModel)) {
+            const backend = this.#mantleBackend();
+            if (backend === undefined)
+                return this.#missingMantleResponse();
+            return backend.chat(body, signal, options);
+        }
         let input;
         try {
             input = toBedrockConverseInput(body);
@@ -500,6 +631,9 @@ export class BedrockProviderSource {
         return Promise.resolve(Response.json({ error: { type: "not_implemented", message: "Bedrock embeddings are not supported" } }, { status: 501 }));
     }
     reasoningCapabilities(model) {
+        if (model !== undefined && isBedrockOpenAiModel(model)) {
+            return bedrockOpenAiReasoning(model);
+        }
         const known = bedrockReasoningCapabilities(model);
         if (known !== undefined)
             return known;

package/dist/index.d.ts

@@ -7,8 +7,8 @@ export { joinPath, ModelRoutedBackend, OpenAiBackend } from "./backend.js";
 export type { Backend, BackendModelRoute, BackendRequestOptions, BackendResponseMode, RequestAttributionUpdate, ModelRoutedBackendOptions, OpenAiBackendOptions } from "./backend.js";
 export { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "./provider-backends.js";
 export type { ProviderBackendOptions, ProviderTransport } from "./provider-backends.js";
-export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./bedrock-source.js";
-export type { BedrockControlClient, BedrockProviderSourceOptions, BedrockRuntime } from "./bedrock-source.js";
+export { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, fromBedrockConverseOutput, isBedrockOpenAiModel, toBedrockConverseInput } from "./bedrock-source.js";
+export type { BedrockControlClient, BedrockMantleBackend, BedrockProviderSourceOptions, BedrockRuntime } from "./bedrock-source.js";
 export { CatalogBackend, DEFAULT_LEADERBOARD_DURABLE_RETENTION_DAYS, DEFAULT_LEADERBOARD_LIVE_LIMIT, DEFAULT_LEADERBOARD_LIVE_TTL_HOURS, isSubscriptionProvider, leaderboardConfigSchema, NoModelAvailableError, modelPolicyAllowsModel, modelPolicyRuleMatches, normalizeRouterConfigAliases, parseRouterConfig, resolveLeaderboardConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
 export type { CatalogBackendOptions, CatalogModelInfo, LeaderboardConfig, ModelPolicy, ProviderPolicy, RouterConfig } from "./router.js";
 export { API_PROVIDER_IDS, ApiProviderSource, parseDiscoveredModels, parseReasoningCapabilities, PROVIDER_IDS, SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";

package/dist/index.js

@@ -3,7 +3,7 @@ export { startGateway } from "./server.js";
 export { startSwitchingGatewayProxy } from "./switching-proxy.js";
 export { joinPath, ModelRoutedBackend, OpenAiBackend } from "./backend.js";
 export { AnthropicBackend, CodexResponsesBackend, GoogleGenAiBackend } from "./provider-backends.js";
-export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./bedrock-source.js";
+export { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, fromBedrockConverseOutput, isBedrockOpenAiModel, toBedrockConverseInput } from "./bedrock-source.js";
 export { CatalogBackend, DEFAULT_LEADERBOARD_DURABLE_RETENTION_DAYS, DEFAULT_LEADERBOARD_LIVE_LIMIT, DEFAULT_LEADERBOARD_LIVE_TTL_HOURS, isSubscriptionProvider, leaderboardConfigSchema, NoModelAvailableError, modelPolicyAllowsModel, modelPolicyRuleMatches, normalizeRouterConfigAliases, parseRouterConfig, resolveLeaderboardConfig, routerConfigSchema, splitNamespacedModel, UnknownModelError } from "./router.js";
 export { API_PROVIDER_IDS, ApiProviderSource, parseDiscoveredModels, parseReasoningCapabilities, PROVIDER_IDS, SUBSCRIPTION_PROVIDER_IDS } from "./provider-source.js";
 export { OpenRouterModelMetadataClient, resolveCodexStartupModel } from "./codex-model-selection.js";

package/dist/router.js

@@ -280,8 +280,12 @@ export function modelPolicyAllowsModel(policy, canonicalModel) {
  * verified; provider discovery and explicit config always take precedence.
  */
 export function inferKnownReasoningCapabilities(provider, model) {
-    if (provider === "openai" &&
-        /^gpt-5\.6(?:-(?:sol|terra|luna))?(?:-\d{4}-\d{2}-\d{2})?$/.test(model)) {
+    const bedrockOpenAi = provider === "bedrock" && /^(?:(?:us|eu|global)\.)?openai\./.test(model)
+        ? model.replace(/^(?:(?:us|eu|global)\.)?openai\./, "")
+        : undefined;
+    const openaiModel = bedrockOpenAi ?? (provider === "openai" ? model : undefined);
+    if (openaiModel !== undefined &&
+        /^gpt-5\.6(?:-(?:sol|terra|luna))?(?:-\d{4}-\d{2}-\d{2})?$/.test(openaiModel)) {
         return {
             status: "supported",
             efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
@@ -290,6 +294,15 @@ export function inferKnownReasoningCapabilities(provider, model) {
             provenance: "builtin"
         };
     }
+    if (bedrockOpenAi !== undefined &&
+        /^gpt-5\.(?:4|5)(?:-\d{4}-\d{2}-\d{2})?$/.test(bedrockOpenAi)) {
+        return {
+            status: "supported",
+            efforts: ["none", "low", "medium", "high", "xhigh"].map((id) => ({ id })),
+            wireShape: "openai-responses",
+            provenance: "builtin"
+        };
+    }
     if (provider === "openai" && /^gpt-5\.5(?:-\d{4}-\d{2}-\d{2})?$/.test(model)) {
         return {
             status: "supported",

package/dist/switching-proxy.d.ts

@@ -5,6 +5,7 @@ export type SwitchingGatewayProxy = {
     target(): string;
     swapTarget(target: string): string;
     waitForTargetIdle(target: string, graceMs: number): Promise<boolean>;
+    retire(graceMs?: number): Promise<void>;
     drain(graceMs?: number): Promise<void>;
     close(): Promise<void>;
 };

package/dist/switching-proxy.js

@@ -68,13 +68,17 @@ function writeJson(res, status, value) {
     res.setHeader("content-length", String(payload.length));
     res.end(payload);
 }
-async function pipe(res, upstream) {
+async function pipe(res, upstream, closeConnection) {
     res.statusCode = upstream.status;
     for (const [name, value] of upstream.headers) {
         if (!HOP_BY_HOP.has(name.toLowerCase()) && name.toLowerCase() !== "content-length") {
             res.setHeader(name, value);
         }
     }
+    if (closeConnection()) {
+        res.shouldKeepAlive = false;
+        res.setHeader("connection", "close");
+    }
     if (upstream.body === null) {
         res.end();
         return;
@@ -108,8 +112,13 @@ export async function startSwitchingGatewayProxy(input) {
     };
     const generations = new Map([[active.url, active]]);
     let draining = false;
+    let retiring = false;
     let inflight = 0;
     const server = createServer((req, res) => {
+        if (retiring) {
+            res.shouldKeepAlive = false;
+            res.setHeader("connection", "close");
+        }
         inflight += 1;
         res.once("close", () => {
             inflight -= 1;
@@ -170,7 +179,7 @@ export async function startSwitchingGatewayProxy(input) {
                         AbortSignal.timeout(10 * 60 * 1000)
                     ])
                 });
-                await pipe(res, upstream);
+                await pipe(res, upstream, () => retiring);
             }
             catch {
                 if (!res.destroyed && !res.headersSent) {
@@ -205,14 +214,33 @@ export async function startSwitchingGatewayProxy(input) {
     const address = server.address();
     const port = typeof address === "object" && address !== null ? address.port : input.port ?? 0;
     let drainRun;
+    let retireRun;
+    const waitForInflight = async (graceMs) => {
+        const deadline = Date.now() + graceMs;
+        while (inflight > 0 && Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    };
+    const closeRetiringListener = async (graceMs) => {
+        server.closeIdleConnections();
+        const closed = new Promise((resolve) => server.close(() => resolve()));
+        await waitForInflight(graceMs);
+        if (inflight > 0)
+            server.closeAllConnections();
+        await closed;
+    };
+    const retire = (graceMs = 0) => {
+        retireRun ??= (async () => {
+            retiring = true;
+            await closeRetiringListener(graceMs);
+        })();
+        return retireRun;
+    };
     const drain = (graceMs = 0) => {
         drainRun ??= (async () => {
             draining = true;
             server.closeIdleConnections();
-            const deadline = Date.now() + graceMs;
-            while (inflight > 0 && Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
+            await waitForInflight(graceMs);
             const closed = new Promise((resolve) => server.close(() => resolve()));
             server.closeAllConnections();
             await closed;
@@ -252,6 +280,7 @@ export async function startSwitchingGatewayProxy(input) {
                 generations.delete(generation.url);
             return result;
         },
+        retire,
         drain,
         close: async () => await drain(0)
     };

package/dist/test/bedrock-source.test.js

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 import { ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
 import { ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";
-import { BedrockProviderSource, toBedrockConverseInput } from "../bedrock-source.js";
+import { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, isBedrockOpenAiModel, toBedrockConverseInput } from "../bedrock-source.js";
 test("Bedrock discovery includes active Anthropic foundations and paginated backed profiles", async () => {
     const commands = [];
     const source = new BedrockProviderSource({
@@ -392,6 +392,135 @@ test("Bedrock groups parallel tool results into one user message", () => {
         ]
     });
 });
+test("Bedrock OpenAI model ids stay on mantle and never match Anthropic Converse", () => {
+    assert.equal(isBedrockOpenAiModel("openai.gpt-5.4"), true);
+    assert.equal(isBedrockOpenAiModel("openai.gpt-5.6-sol"), true);
+    assert.equal(isBedrockOpenAiModel("us.openai.gpt-5.6-terra"), true);
+    assert.equal(isBedrockOpenAiModel("anthropic.claude-3"), false);
+    assert.equal(isBedrockOpenAiModel("us.anthropic.claude-3"), false);
+});
+test("Bedrock discovery unions OpenAI mantle models when a Bedrock API key is present", async () => {
+    const source = new BedrockProviderSource({
+        env: { AWS_BEARER_TOKEN_BEDROCK: "bedrock-key", AWS_REGION: "us-east-1" },
+        controlClient: {
+            send: async (command) => {
+                if (command instanceof ListFoundationModelsCommand)
+                    return {
+                        modelSummaries: [{
+                                modelId: "anthropic.claude-3",
+                                providerName: "Anthropic",
+                                modelLifecycle: { status: "ACTIVE" }
+                            }]
+                    };
+                return { inferenceProfileSummaries: [] };
+            }
+        },
+        runtimeClient: { send: async () => ({}) }
+    });
+    const discovered = await source.discoverModels();
+    assert.deepEqual(discovered.map((model) => model.id), ["anthropic.claude-3", ...BEDROCK_OPENAI_ALLOWLIST]);
+    const sol = discovered.find((model) => model.id === "openai.gpt-5.6-sol");
+    assert.equal(sol?.reasoning?.wireShape, "openai-responses");
+    assert.equal(sol?.reasoning?.defaultEffort, "medium");
+});
+test("Bedrock discovery keeps OpenAI models when Anthropic listing fails and a key is present", async () => {
+    const source = new BedrockProviderSource({
+        env: { AWS_BEARER_TOKEN_BEDROCK: "bedrock-key", AWS_REGION: "us-east-1" },
+        controlClient: {
+            send: async () => {
+                throw new Error("not authorized");
+            }
+        },
+        runtimeClient: { send: async () => ({}) }
+    });
+    const discovered = await source.discoverModels();
+    assert.deepEqual(discovered.map((model) => model.id), [...BEDROCK_OPENAI_ALLOWLIST]);
+});
+test("Bedrock routes OpenAI models through mantle and leaves Anthropic on Converse", async () => {
+    const runtimeCalls = [];
+    const mantleCalls = [];
+    const source = new BedrockProviderSource({
+        env: { AWS_BEARER_TOKEN_BEDROCK: "bedrock-key", AWS_REGION: "us-east-1" },
+        controlClient: { send: async () => ({}) },
+        runtimeClient: {
+            send: async (value) => {
+                runtimeCalls.push(value);
+                return {
+                    $metadata: { requestId: "req-1" },
+                    output: { message: { role: "assistant", content: [{ text: "claude" }] } },
+                    stopReason: "end_turn"
+                };
+            }
+        },
+        mantleBackend: {
+            chat: async (body) => {
+                const model = typeof body.model === "string"
+                    ? body.model
+                    : undefined;
+                mantleCalls.push({ kind: "chat", ...(model !== undefined ? { model } : {}) });
+                return Response.json({ id: "chat", model });
+            },
+            responses: async (body) => {
+                const model = typeof body.model === "string"
+                    ? body.model
+                    : undefined;
+                mantleCalls.push({ kind: "responses", ...(model !== undefined ? { model } : {}) });
+                return Response.json({ id: "resp", model });
+            }
+        }
+    });
+    assert.equal(source.supportsResponses("openai.gpt-5.4"), true);
+    assert.equal(source.supportsResponses("anthropic.claude-3"), false);
+    assert.equal(source.reasoningCapabilities("openai.gpt-5.6-sol")?.wireShape, "openai-responses");
+    const openaiChat = await source.chat({
+        model: "openai.gpt-5.4",
+        messages: [{ role: "user", content: "hi" }]
+    });
+    assert.equal(openaiChat.status, 200);
+    assert.deepEqual(await openaiChat.json(), { id: "chat", model: "openai.gpt-5.4" });
+    const openaiResponses = await source.responses({
+        model: "openai.gpt-5.6-terra",
+        input: "hi"
+    });
+    assert.equal(openaiResponses.status, 200);
+    assert.deepEqual(await openaiResponses.json(), { id: "resp", model: "openai.gpt-5.6-terra" });
+    const anthropic = await source.chat({
+        model: "anthropic.claude-3",
+        messages: [{ role: "user", content: "hi" }]
+    });
+    assert.equal(anthropic.status, 200);
+    assert.equal(runtimeCalls.length, 1);
+    assert.equal(runtimeCalls[0] instanceof ConverseCommand, true);
+    assert.deepEqual(mantleCalls, [
+        { kind: "chat", model: "openai.gpt-5.4" },
+        { kind: "responses", model: "openai.gpt-5.6-terra" }
+    ]);
+    const rejected = await source.responses({
+        model: "anthropic.claude-3",
+        input: "hi"
+    });
+    assert.equal(rejected.status, 501);
+});
+test("Bedrock OpenAI chat without a mantle key returns 400 and does not call Converse", async () => {
+    const runtimeCalls = [];
+    const source = new BedrockProviderSource({
+        env: { AWS_REGION: "us-east-1" },
+        controlClient: { send: async () => ({}) },
+        runtimeClient: {
+            send: async (value) => {
+                runtimeCalls.push(value);
+                return {};
+            }
+        }
+    });
+    const response = await source.chat({
+        model: "openai.gpt-5.5",
+        messages: [{ role: "user", content: "hi" }]
+    });
+    assert.equal(response.status, 400);
+    assert.match(await response.text(), /AWS_BEARER_TOKEN_BEDROCK/);
+    assert.equal(runtimeCalls.length, 0);
+});
 test("Bedrock defaults reasoning to unknown and ordinary requests omit thinking", () => {
     const source = new BedrockProviderSource({
         controlClient: { send: async () => ({}) },

package/dist/test/router.test.js

@@ -768,3 +768,36 @@ test("Bedrock Opus 5 exposes reasoning controls and accepts routed effort select
     const error = (await rejected.json());
     assert.equal(error.error.code, "unsupported_reasoning_control");
 });
+test("Bedrock OpenAI models keep native openai. ids and Responses reasoning", async () => {
+    const calls = [];
+    const backend = await CatalogBackend.create({
+        config: { providers: { bedrock: {} }, defaultModel: "bedrock/openai.gpt-5.6-sol" },
+        sources: {
+            bedrock: {
+                ...fakeSource("bedrock", [{ id: "openai.gpt-5.6-sol" }], calls),
+                supportsResponses(model) {
+                    return model.startsWith("openai.");
+                },
+                async responses(body) {
+                    const model = typeof body === "object" &&
+                        body !== null &&
+                        "model" in body &&
+                        typeof body.model === "string"
+                        ? body.model
+                        : undefined;
+                    calls.push({ source: "bedrock-responses", ...(model !== undefined ? { model } : {}) });
+                    return Response.json({ ok: true, model });
+                }
+            }
+        }
+    });
+    assert.equal(backend.supportsResponses("bedrock/openai.gpt-5.6-sol"), true);
+    assert.equal(backend.modelInfo("bedrock/openai.gpt-5.6-sol")?.reasoning?.wireShape, "openai-responses");
+    const response = await backend.responses({
+        model: "bedrock/openai.gpt-5.6-sol",
+        input: "hi"
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), { ok: true, model: "openai.gpt-5.6-sol" });
+    assert.deepEqual(calls, [{ source: "bedrock-responses", model: "openai.gpt-5.6-sol" }]);
+});

package/dist/test/switching-proxy-retire.test.d.ts

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

package/dist/test/switching-proxy-retire.test.js

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import { createServer } from "node:http";
+import test from "node:test";
+import { startSwitchingGatewayProxy } from "../switching-proxy.js";
+async function heldTarget() {
+    let markStarted;
+    const started = new Promise((resolve) => {
+        markStarted = resolve;
+    });
+    let release;
+    const released = new Promise((resolve) => {
+        release = resolve;
+    });
+    const server = createServer((request, response) => {
+        if (request.url === "/stream") {
+            response.setHeader("content-type", "text/plain");
+            response.write("first\n");
+            markStarted();
+            void released.then(() => response.end("last\n"));
+            return;
+        }
+        response.end("ok");
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const port = server.address().port;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        started,
+        release,
+        close: async () => await new Promise((resolve, reject) => server.close((error) => (error === undefined ? resolve() : reject(error))))
+    };
+}
+test("switching proxy retirement preserves an admitted streaming response", async () => {
+    const target = await heldTarget();
+    const proxy = await startSwitchingGatewayProxy({ target: target.url });
+    try {
+        const response = await fetch(`${proxy.url()}/stream`);
+        const reader = response.body?.getReader();
+        assert.ok(reader !== undefined);
+        const first = await reader.read();
+        assert.match(Buffer.from(first.value ?? []).toString("utf8"), /first/);
+        await target.started;
+        const retiring = proxy.retire(2_000);
+        target.release();
+        let remainder = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            remainder += Buffer.from(value ?? []).toString("utf8");
+        }
+        assert.match(remainder, /last/);
+        await retiring;
+    }
+    finally {
+        await proxy.close();
+        await target.close();
+    }
+});
+test("switching proxy retirement deadline terminates a stream that never finishes", async () => {
+    const target = await heldTarget();
+    const proxy = await startSwitchingGatewayProxy({ target: target.url });
+    try {
+        const response = await fetch(`${proxy.url()}/stream`);
+        const reader = response.body?.getReader();
+        assert.ok(reader !== undefined);
+        await reader.read();
+        await target.started;
+        const startedAt = Date.now();
+        await proxy.retire(250);
+        assert.ok(Date.now() - startedAt >= 200);
+        await assert.rejects(async () => {
+            for (;;) {
+                const { done } = await reader.read();
+                if (done)
+                    break;
+            }
+        });
+    }
+    finally {
+        target.release();
+        await proxy.close();
+        await target.close();
+    }
+});

package/package.json

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