@velum-labs/routekit-gateway 0.18.3 → 0.18.5

package/dist/bedrock-source.d.ts

@@ -13,6 +13,16 @@ export type BedrockProviderSourceOptions = {
 };
 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;
+/**
+ * Codex talks to RouteKit as OpenAI-compatible, so it sends OpenAI/Codex
+ * protocol items that Bedrock mantle rejects. Native OpenAI is unchanged.
+ *
+ * - `search_content_types` on `web_search*`
+ * - `agent_message` (Codex 0.147 subagent handoff)
+ * - `encrypted_content` content parts (same 400 as `agent_message`)
+ * - `compaction` / `reasoning` encrypted blobs without `rsn_` / `smry_`
+ */
+export declare function sanitizeBedrockMantleRequestBody(body: unknown): unknown;
 export declare function toBedrockConverseInput(body: unknown): ConverseCommandInput;
 export declare function fromBedrockConverseOutput(output: ConverseCommandOutput, model: string): Record<string, unknown>;
 export declare class BedrockProviderSource implements ProviderSource {

package/dist/bedrock-source.js

@@ -14,6 +14,95 @@ const BEDROCK_OPENAI_MODEL = /^(?:(?:us|eu|global)\.)?openai\.gpt-/;
 export function isBedrockOpenAiModel(modelId) {
     return BEDROCK_OPENAI_MODEL.test(modelId);
 }
+/**
+ * Codex talks to RouteKit as OpenAI-compatible, so it sends OpenAI/Codex
+ * protocol items that Bedrock mantle rejects. Native OpenAI is unchanged.
+ *
+ * - `search_content_types` on `web_search*`
+ * - `agent_message` (Codex 0.147 subagent handoff)
+ * - `encrypted_content` content parts (same 400 as `agent_message`)
+ * - `compaction` / `reasoning` encrypted blobs without `rsn_` / `smry_`
+ */
+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 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;
+}
 function mantleApiKey(env) {
     const key = env.AWS_BEARER_TOKEN_BEDROCK ?? env.BEDROCK_API_KEY;
     return typeof key === "string" && key.length > 0 ? key : undefined;
@@ -588,7 +677,7 @@ export class BedrockProviderSource {
         const backend = this.#mantleBackend();
         if (backend === undefined)
             return this.#missingMantleResponse();
-        return backend.responses(body, signal, options);
+        return backend.responses(sanitizeBedrockMantleRequestBody(body), signal, options);
     }
     async chat(body, signal, options) {
         const requestedModel = record(body)?.model;
@@ -596,7 +685,7 @@ export class BedrockProviderSource {
             const backend = this.#mantleBackend();
             if (backend === undefined)
                 return this.#missingMantleResponse();
-            return backend.chat(body, signal, options);
+            return backend.chat(sanitizeBedrockMantleRequestBody(body), signal, options);
         }
         let input;
         try {

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 { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, isBedrockOpenAiModel, toBedrockConverseInput } from "../bedrock-source.js";
+import { BEDROCK_OPENAI_ALLOWLIST, BedrockProviderSource, isBedrockOpenAiModel, sanitizeBedrockMantleRequestBody, toBedrockConverseInput } from "../bedrock-source.js";
 test("Bedrock discovery includes active Anthropic foundations and paginated backed profiles", async () => {
     const commands = [];
     const source = new BedrockProviderSource({
@@ -501,6 +501,132 @@ test("Bedrock routes OpenAI models through mantle and leaves Anthropic on Conver
     });
     assert.equal(rejected.status, 501);
 });
+test("sanitizeBedrockMantleRequestBody strips search_content_types from web_search only", () => {
+    const lookup = {
+        type: "function",
+        name: "lookup",
+        parameters: { type: "object" }
+    };
+    const body = {
+        model: "openai.gpt-5.6-sol",
+        tools: [
+            { type: "web_search", search_content_types: ["text", "image"], external_web_access: true },
+            lookup
+        ]
+    };
+    assert.deepEqual(sanitizeBedrockMantleRequestBody(body), {
+        model: "openai.gpt-5.6-sol",
+        tools: [{ type: "web_search", external_web_access: true }, lookup]
+    });
+    const noTools = { model: "openai.gpt-5.6-sol", input: "hi" };
+    assert.equal(sanitizeBedrockMantleRequestBody(noTools), noTools);
+    const untouched = { model: "openai.gpt-5.6-sol", tools: [{ type: "web_search" }] };
+    assert.equal(sanitizeBedrockMantleRequestBody(untouched), untouched);
+});
+test("sanitizeBedrockMantleRequestBody rewrites Codex agent_message and drops encrypted_content", () => {
+    const body = {
+        model: "openai.gpt-5.6-sol",
+        input: [
+            {
+                type: "agent_message",
+                author: "/root",
+                recipient: "/root/package_architecture",
+                content: [
+                    { type: "input_text", text: "Reply with exactly PONG" },
+                    { type: "encrypted_content", encrypted_content: " " }
+                ]
+            },
+            {
+                type: "message",
+                role: "user",
+                content: [
+                    { type: "input_text", text: "keep" },
+                    { 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",
+        input: [
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: "Reply with exactly PONG" }]
+            },
+            {
+                type: "message",
+                role: "user",
+                content: [{ type: "input_text", text: "keep" }]
+            },
+            { type: "reasoning", encrypted_content: "rsn_ok", summary: [] }
+        ]
+    });
+});
+test("Bedrock mantle Responses drops Codex search_content_types 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: async () => Response.json({}),
+            responses: async (body) => {
+                forwarded.push(body);
+                return Response.json({ id: "resp" });
+            }
+        }
+    });
+    const response = await source.responses({
+        model: "openai.gpt-5.6-sol",
+        input: "hi",
+        tools: [{ type: "web_search", search_content_types: ["text", "image"] }]
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(forwarded, [
+        {
+            model: "openai.gpt-5.6-sol",
+            input: "hi",
+            tools: [{ type: "web_search" }]
+        }
+    ]);
+});
+test("Bedrock mantle Responses rewrites Codex agent_message 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: async () => Response.json({}),
+            responses: async (body) => {
+                forwarded.push(body);
+                return Response.json({ id: "resp" });
+            }
+        }
+    });
+    const response = await source.responses({
+        model: "openai.gpt-5.6-sol",
+        input: [{
+                type: "agent_message",
+                author: "/root",
+                recipient: "/root/async_lifecycle",
+                content: [
+                    { type: "input_text", text: "hi" },
+                    { type: "encrypted_content", encrypted_content: " " }
+                ]
+            }]
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(forwarded, [
+        {
+            model: "openai.gpt-5.6-sol",
+            input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hi" }] }]
+        }
+    ]);
+});
 test("Bedrock OpenAI chat without a mantle key returns 400 and does not call Converse", async () => {
     const runtimeCalls = [];
     const source = new BedrockProviderSource({

package/package.json

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