@velum-labs/routekit-gateway 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -19,8 +19,8 @@ export type { EvalSessionAdmission, GatewayPrincipal, WorkloadJwtPrincipalPolicy
 export { authorizedRequest, createWorkloadJwtVerifier, parsePrincipalHeader, presentedCredential, ROUTEKIT_PRINCIPAL_HEADER, resolvePrincipal } from "./http/auth.js";
 export type { Backend, BackendLifecyclePort, BackendModelPort, BackendModelRoute, BackendPorts, BackendRequest, BackendRequestOptions, BackendResponseMode, BackendResponsesPort, ModelRoutedBackendOptions, RequestAttributionUpdate } from "./providers/backend.js";
 export { borrowedBackendPorts, joinPath, ModelRoutedBackend, staticBackendModelPort } from "./providers/backend.js";
-export type { BedrockControlClient, BedrockProviderSourceOptions, BedrockRuntime } from "./providers/bedrock-source.js";
-export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./providers/bedrock-source.js";
+export type { BedrockControlClient, BedrockMantleBackend, BedrockProviderSourceOptions, BedrockRuntime } from "./providers/bedrock-source.js";
+export { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, fromBedrockConverseOutput, isBedrockOpenAiModel, toBedrockConverseInput } from "./providers/bedrock-source.js";
 export type { CapacityLease, CapacityPoolMember, CapacityPoolOptions, CapacityPoolStrategy } from "./capacity-pool.js";
 export { CapacityPool } from "./capacity-pool.js";
 export type { OpenRouterModelMetadata, OpenRouterModelMetadataClientOptions, ResolvedCodexStartupSelection } from "./providers/codex-model-selection.js";

package/dist/index.js

@@ -10,7 +10,7 @@ export { chatToResponses, handleResponses, openAiSseToResponses, responsesToChat
 export { MAX_WEB_SEARCHES_PER_TURN, resolveWebSearchExecutor } from "./adapters/web-search.js";
 export { authorizedRequest, createWorkloadJwtVerifier, parsePrincipalHeader, presentedCredential, ROUTEKIT_PRINCIPAL_HEADER, resolvePrincipal } from "./http/auth.js";
 export { borrowedBackendPorts, joinPath, ModelRoutedBackend, staticBackendModelPort } from "./providers/backend.js";
-export { BedrockProviderSource, fromBedrockConverseOutput, toBedrockConverseInput } from "./providers/bedrock-source.js";
+export { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, fromBedrockConverseOutput, isBedrockOpenAiModel, toBedrockConverseInput } from "./providers/bedrock-source.js";
 export { CapacityPool } from "./capacity-pool.js";
 export { OpenRouterModelMetadataClient, resolveCodexStartupModel } from "./providers/codex-model-selection.js";
 export { CompositionalRoutingError, routeCompositionalRequest } from "./routing/compositional.js";

package/dist/providers/bedrock-source.d.ts

@@ -1,19 +1,30 @@
 /**
- * Amazon Bedrock provider source. Discovers Anthropic foundation models and
- * inference profiles, then sends chat through Bedrock Converse. OpenAI Chat
- * Completions JSON ↔ Converse translation lives in `bedrock-codec.ts`.
+ * Amazon Bedrock provider source. Anthropic models use Bedrock Converse;
+ * allowlisted OpenAI frontier models use the regional bedrock-mantle
+ * OpenAI-compatible API.
  */
 import { BedrockClient } from "@aws-sdk/client-bedrock";
 import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
 import { fromBedrockConverseOutput, toBedrockConverseInput } from "./bedrock-codec.js";
+import { OpenAiBackend } from "./openai-backend.js";
 import type { ProviderSource } from "./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?: Readonly<Record<string, string | undefined>>;
+    mantleBackend?: BedrockMantleBackend;
 };
 export { fromBedrockConverseOutput, toBedrockConverseInput };
+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;
+/**
+ * Remove OpenAI/Codex protocol fields that bedrock-mantle rejects while
+ * leaving native OpenAI egress unchanged.
+ */
+export declare function sanitizeBedrockMantleRequestBody(body: unknown): unknown;
 export declare class BedrockProviderSource implements ProviderSource {
     #private;
     readonly sourceId: "bedrock";

package/dist/providers/bedrock-source.js

@@ -1,20 +1,173 @@
 /**
- * Amazon Bedrock provider source. Discovers Anthropic foundation models and
- * inference profiles, then sends chat through Bedrock Converse. OpenAI Chat
- * Completions JSON ↔ Converse translation lives in `bedrock-codec.ts`.
+ * Amazon Bedrock provider source. Anthropic models use Bedrock Converse;
+ * allowlisted OpenAI frontier models use the regional bedrock-mantle
+ * OpenAI-compatible API.
  */
 import { BedrockClient, ListFoundationModelsCommand, ListInferenceProfilesCommand } from "@aws-sdk/client-bedrock";
 import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
 import { RouteKitFailure } from "@velum-labs/routekit-runtime/effect";
 import { Effect } from "effect";
 import { errorResponse, fromBedrockConverseOutput, isOpusFiveModel, streamResponse, toBedrockConverseInput } from "./bedrock-codec.js";
+import { OpenAiBackend } from "./openai-backend.js";
 import { gatewayTry, gatewayTryPromise } from "../effect/gateway.js";
 export { fromBedrockConverseOutput, toBedrockConverseInput };
+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 record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value)
         ? value
         : undefined;
 }
+function recognizedEncryptedPrefix(value) {
+    return typeof value === "string" && (value.startsWith("rsn_") || value.startsWith("smry_"));
+}
+function sanitizeBedrockMantleContent(content) {
+    if (!Array.isArray(content))
+        return { content, changed: false };
+    const parts = content.filter((part) => record(part)?.type !== "encrypted_content");
+    return { content: parts, changed: parts.length !== content.length };
+}
+function sanitizeBedrockMantleInputItem(item) {
+    const entry = record(item);
+    if (entry === undefined)
+        return item;
+    const type = typeof entry.type === "string" ? entry.type : "";
+    if (type === "compaction" &&
+        "encrypted_content" in entry &&
+        !recognizedEncryptedPrefix(entry.encrypted_content)) {
+        return undefined;
+    }
+    if (type === "agent_message") {
+        const { content } = sanitizeBedrockMantleContent(entry.content);
+        return { type: "message", role: "user", content };
+    }
+    let next = entry;
+    let changed = false;
+    if (Array.isArray(entry.content)) {
+        const sanitized = sanitizeBedrockMantleContent(entry.content);
+        if (sanitized.changed) {
+            next = { ...next, content: sanitized.content };
+            changed = true;
+        }
+    }
+    if (type === "reasoning" &&
+        "encrypted_content" in next &&
+        !recognizedEncryptedPrefix(next.encrypted_content)) {
+        const { encrypted_content: _ignored, ...rest } = next;
+        next = rest;
+        changed = true;
+    }
+    return changed ? next : item;
+}
+/**
+ * Remove OpenAI/Codex protocol fields that bedrock-mantle rejects while
+ * leaving native OpenAI egress unchanged.
+ */
+export function sanitizeBedrockMantleRequestBody(body) {
+    const payload = record(body);
+    if (payload === undefined)
+        return body;
+    let next = payload;
+    let changed = false;
+    if (Array.isArray(payload.tools)) {
+        const tools = payload.tools.map((tool) => {
+            const entry = record(tool);
+            if (entry === undefined)
+                return tool;
+            const type = typeof entry.type === "string" ? entry.type : "";
+            if (!type.startsWith("web_search") || !("search_content_types" in entry))
+                return tool;
+            changed = true;
+            const { search_content_types: _ignored, ...rest } = entry;
+            return rest;
+        });
+        if (changed)
+            next = { ...next, tools };
+    }
+    if (Array.isArray(payload.input)) {
+        const input = [];
+        let inputChanged = false;
+        for (const item of payload.input) {
+            const sanitized = sanitizeBedrockMantleInputItem(item);
+            if (sanitized === undefined) {
+                inputChanged = true;
+                continue;
+            }
+            if (sanitized !== item)
+                inputChanged = true;
+            input.push(sanitized);
+        }
+        if (inputChanged) {
+            changed = true;
+            next = { ...next, input };
+        }
+    }
+    return changed ? next : body;
+}
+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 anthropicFoundationModel(model) {
     return (model.providerName?.toLowerCase() === "anthropic" &&
         model.modelLifecycle?.status === "ACTIVE" &&
@@ -96,20 +249,30 @@ export class BedrockProviderSource {
     sourceId = "bedrock";
     discovery;
     requests;
-    responses = { kind: "unsupported" };
+    responses;
     capabilities;
     resource;
     #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;
         this.discovery = { discoverModels: (signal) => this.#discoverModels(signal) };
         this.requests = {
             chat: (body, signal, requestOptions) => this.#chat(body, signal, requestOptions),
             embeddings: () => Effect.succeed(Response.json({ error: { type: "not_implemented", message: "Bedrock embeddings are not supported" } }, { status: 501 }))
         };
+        this.responses = {
+            kind: "responses",
+            supports: (model) => isBedrockOpenAiModel(model),
+            execute: (body, signal, requestOptions) => this.#responses(body, signal, requestOptions)
+        };
         this.capabilities = {
             forModel: () => ({}),
             reasoningForModel: (model) => this.#reasoningCapabilities(model)
@@ -122,32 +285,73 @@ export class BedrockProviderSource {
             })
         };
     }
+    #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 });
+    }
     #discoverModels(signal) {
         const self = this;
         return Effect.gen(function* () {
             self.#inferenceProfilesByFoundation.clear();
             const abort = signal === undefined ? undefined : { abortSignal: signal };
-            const foundation = yield* gatewayTryPromise(() => self.#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());
-            const discovered = new Map(foundations.map((model) => [model.modelId, bedrockDiscoveredModel(model.modelId, model)]));
-            let nextToken;
-            do {
-                const profiles = yield* gatewayTryPromise(() => self.#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) {
-                        self.#inferenceProfilesByFoundation.set(backingId, preferredInferenceProfile(self.#inferenceProfilesByFoundation.get(backingId), profile.inferenceProfileId));
-                        discovered.set(profile.inferenceProfileId, bedrockDiscoveredModel(profile.inferenceProfileId, byId.get(backingId)));
+            const discovered = yield* Effect.gen(function* () {
+                const foundation = yield* gatewayTryPromise(() => self.#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());
+                const anthropic = new Map(foundations.map((model) => [
+                    model.modelId,
+                    bedrockDiscoveredModel(model.modelId, model)
+                ]));
+                let nextToken;
+                do {
+                    const profiles = yield* gatewayTryPromise(() => self.#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) {
+                            self.#inferenceProfilesByFoundation.set(backingId, preferredInferenceProfile(self.#inferenceProfilesByFoundation.get(backingId), profile.inferenceProfileId));
+                            anthropic.set(profile.inferenceProfileId, bedrockDiscoveredModel(profile.inferenceProfileId, byId.get(backingId)));
+                        }
                     }
+                    nextToken = profiles.nextToken;
+                } while (nextToken !== undefined && nextToken.length > 0);
+                return anthropic;
+            }).pipe(Effect.catch((error) => {
+                if (mantleApiKey(self.#env) === undefined)
+                    return Effect.fail(error);
+                self.#inferenceProfilesByFoundation.clear();
+                return Effect.succeed(new Map());
+            }));
+            if (mantleApiKey(self.#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) {
                 return yield* new RouteKitFailure({
                     message: "model discovery returned no active Anthropic Bedrock models"
@@ -156,9 +360,27 @@ export class BedrockProviderSource {
             return [...discovered.values()];
         });
     }
-    #chat(body, signal, _options) {
+    #responses(body, signal, options) {
+        const requestedModel = record(body)?.model;
+        const model = typeof requestedModel === "string" ? requestedModel : "";
+        if (!isBedrockOpenAiModel(model)) {
+            return Effect.succeed(Response.json({ error: { type: "not_supported", message: "native Responses egress is not supported" } }, { status: 501 }));
+        }
+        const backend = this.#mantleBackend();
+        if (backend === undefined)
+            return Effect.succeed(this.#missingMantleResponse());
+        return backend.responses(sanitizeBedrockMantleRequestBody(body), signal, options);
+    }
+    #chat(body, signal, options) {
         const self = this;
         return Effect.gen(function* () {
+            const requestedModel = record(body)?.model;
+            if (typeof requestedModel === "string" && isBedrockOpenAiModel(requestedModel)) {
+                const backend = self.#mantleBackend();
+                if (backend === undefined)
+                    return self.#missingMantleResponse();
+                return yield* backend.chat(sanitizeBedrockMantleRequestBody(body), signal, options);
+            }
             const input = yield* gatewayTry(() => toBedrockConverseInput(body)).pipe(Effect.catch((error) => Effect.succeed(Response.json({
                 error: {
                     type: "invalid_request_error",
@@ -170,7 +392,7 @@ export class BedrockProviderSource {
             const stream = record(body)?.stream === true;
             const modelId = input.modelId;
             if (modelId === undefined)
-                return errorResponse(new Error("Bedrock chat requires a model"));
+                return errorResponse("Bedrock chat requires a model");
             const runtimeModelId = modelId === "anthropic.claude-opus-5"
                 ? (self.#inferenceProfilesByFoundation.get(modelId) ?? modelId)
                 : modelId;
@@ -181,7 +403,7 @@ export class BedrockProviderSource {
                 if (output instanceof Response)
                     return output;
                 if (output.stream === undefined)
-                    return errorResponse(new Error("Bedrock returned no response stream"));
+                    return errorResponse("Bedrock returned no response stream");
                 return streamResponse(output.stream, modelId, signal);
             }
             const output = yield* gatewayTryPromise(() => self.#runtime.send(new ConverseCommand(runtimeInput), abort)).pipe(Effect.catch((error) => Effect.succeed(errorResponse(error))));
@@ -191,6 +413,9 @@ export class BedrockProviderSource {
         });
     }
     #reasoningCapabilities(model) {
+        if (model !== undefined && isBedrockOpenAiModel(model)) {
+            return bedrockOpenAiReasoning(model);
+        }
         const known = bedrockReasoningCapabilities(model);
         if (known !== undefined)
             return known;

package/dist/routing/router.js

@@ -128,7 +128,7 @@ export class RoutingBackend {
                         if (injected !== undefined)
                             return injected;
                         if (provider === "bedrock")
-                            return new BedrockProviderSource();
+                            return new BedrockProviderSource({ env });
                         if (isApiProvider(provider)) {
                             return (options.createApiSource?.(provider, env) ??
                                 new ApiProviderSource({ provider, env }));

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

@@ -3,7 +3,8 @@ import { test } from "node:test";
 import { ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";
 import { ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
 import { runRouteKitEffect } from "@velum-labs/routekit-runtime/effect";
-import { BedrockProviderSource, toBedrockConverseInput } from "../providers/bedrock-source.js";
+import { Effect } from "effect";
+import { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, isBedrockOpenAiModel, sanitizeBedrockMantleRequestBody, toBedrockConverseInput } from "../providers/bedrock-source.js";
 test("Bedrock discovery includes active Anthropic foundations and paginated backed profiles", async () => {
     const commands = [];
     const source = new BedrockProviderSource({
@@ -124,6 +125,192 @@ test("Bedrock discovery includes active Anthropic foundations and paginated back
     assert.deepEqual(discovered[3]?.reasoning, discovered[1]?.reasoning);
     assert.equal(commands.length, 3);
 });
+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 bearer token 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 runRouteKitEffect(source.discovery.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", 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 runRouteKitEffect(source.discovery.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: (body) => {
+                const model = typeof body.model === "string"
+                    ? body.model
+                    : undefined;
+                mantleCalls.push({ kind: "chat", ...(model !== undefined ? { model } : {}) });
+                return Effect.succeed(Response.json({ id: "chat", model }));
+            },
+            responses: (body) => {
+                const model = typeof body.model === "string"
+                    ? body.model
+                    : undefined;
+                mantleCalls.push({ kind: "responses", ...(model !== undefined ? { model } : {}) });
+                return Effect.succeed(Response.json({ id: "resp", model }));
+            }
+        }
+    });
+    assert.equal(source.responses.kind === "responses" && source.responses.supports("openai.gpt-5.4"), true);
+    assert.equal(source.responses.kind === "responses" && source.responses.supports("anthropic.claude-3"), false);
+    assert.equal(source.capabilities.reasoningForModel("openai.gpt-5.6-sol")?.wireShape, "openai-responses");
+    const openaiChat = await runRouteKitEffect(source.requests.chat({
+        model: "openai.gpt-5.4",
+        messages: [{ role: "user", content: "hi" }]
+    }));
+    assert.deepEqual(await openaiChat.json(), { id: "chat", model: "openai.gpt-5.4" });
+    assert.equal(source.responses.kind, "responses");
+    if (source.responses.kind !== "responses")
+        throw new Error("expected Responses support");
+    const openaiResponses = await runRouteKitEffect(source.responses.execute({
+        model: "openai.gpt-5.6-terra",
+        input: "hi"
+    }));
+    assert.deepEqual(await openaiResponses.json(), {
+        id: "resp",
+        model: "openai.gpt-5.6-terra"
+    });
+    const anthropic = await runRouteKitEffect(source.requests.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 runRouteKitEffect(source.responses.execute({
+        model: "anthropic.claude-3",
+        input: "hi"
+    }));
+    assert.equal(rejected.status, 501);
+});
+test("Bedrock mantle sanitizes Codex-only request fields before egress", async () => {
+    const forwarded = [];
+    const source = new BedrockProviderSource({
+        env: { AWS_BEARER_TOKEN_BEDROCK: "bedrock-key", AWS_REGION: "us-east-1" },
+        controlClient: { send: async () => ({}) },
+        runtimeClient: { send: async () => ({}) },
+        mantleBackend: {
+            chat: () => Effect.succeed(Response.json({})),
+            responses: (body) => {
+                forwarded.push(body);
+                return Effect.succeed(Response.json({ id: "resp" }));
+            }
+        }
+    });
+    const body = {
+        model: "openai.gpt-5.6-sol",
+        tools: [{ type: "web_search", search_content_types: ["text", "image"] }],
+        input: [
+            {
+                type: "agent_message",
+                author: "/root",
+                recipient: "/root/worker",
+                content: [
+                    { type: "input_text", text: "hi" },
+                    { type: "encrypted_content", encrypted_content: " " }
+                ]
+            },
+            { type: "compaction", encrypted_content: "not-a-prefix" },
+            { type: "reasoning", encrypted_content: "rsn_ok", summary: [] }
+        ]
+    };
+    assert.deepEqual(sanitizeBedrockMantleRequestBody(body), {
+        model: "openai.gpt-5.6-sol",
+        tools: [{ type: "web_search" }],
+        input: [
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: "hi" }]
+            },
+            { type: "reasoning", encrypted_content: "rsn_ok", summary: [] }
+        ]
+    });
+    assert.equal(source.responses.kind, "responses");
+    if (source.responses.kind !== "responses")
+        throw new Error("expected Responses support");
+    const response = await runRouteKitEffect(source.responses.execute(body));
+    assert.equal(response.status, 200);
+    assert.deepEqual(forwarded, [sanitizeBedrockMantleRequestBody(body)]);
+});
+test("Bedrock OpenAI chat without a mantle key returns 400 and skips 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 runRouteKitEffect(source.requests.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 request translation covers system, image, tools, results, and inference config", () => {
     const input = toBedrockConverseInput({
         model: "us.anthropic.claude-3",

package/dist/test/router.test.js

@@ -936,3 +936,53 @@ 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 ids and route through Responses", async () => {
+    const calls = [];
+    const bedrock = fakeSource("bedrock", [
+        {
+            id: "openai.gpt-5.6-sol",
+            reasoning: {
+                status: "supported",
+                efforts: ["none", "low", "medium", "high", "xhigh", "max"].map((id) => ({ id })),
+                defaultEffort: "medium",
+                wireShape: "openai-responses",
+                provenance: "builtin"
+            }
+        }
+    ], calls);
+    const backend = await runRouteKitEffect(RoutingBackend.create({
+        config: { providers: { bedrock: {} }, defaultModel: "bedrock/openai.gpt-5.6-sol" },
+        sources: {
+            bedrock: {
+                ...bedrock,
+                responses: {
+                    kind: "responses",
+                    supports: (model) => model.startsWith("openai."),
+                    execute: (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 Effect.succeed(Response.json({ ok: true, model }));
+                    }
+                }
+            }
+        }
+    }));
+    assert.deepEqual(backend.listModelIds(), ["bedrock/openai.gpt-5.6-sol"]);
+    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 runRouteKitEffect(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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@velum-labs/routekit-gateway",
   "private": false,
-  "version": "1.0.4",
+  "version": "1.0.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/velum-labs/routekit.git",
@@ -45,12 +45,12 @@
     "@aws-sdk/client-bedrock": "3.1095.0",
     "@aws-sdk/client-bedrock-runtime": "3.1095.0",
     "effect": "4.0.0-rc.108",
-    "@velum-labs/routekit-config-core": "1.0.4",
-    "@velum-labs/routekit-contracts": "1.0.4",
-    "@velum-labs/routekit-eval-contracts": "1.0.4",
-    "@velum-labs/routekit-eval-core": "1.0.4",
-    "@velum-labs/routekit-registry": "1.0.4",
-    "@velum-labs/routekit-runtime": "1.0.4"
+    "@velum-labs/routekit-config-core": "1.0.6",
+    "@velum-labs/routekit-contracts": "1.0.6",
+    "@velum-labs/routekit-eval-contracts": "1.0.6",
+    "@velum-labs/routekit-eval-core": "1.0.6",
+    "@velum-labs/routekit-registry": "1.0.6",
+    "@velum-labs/routekit-runtime": "1.0.6"
   },
   "keywords": [
     "routekit",