@velum-labs/routekit-gateway 0.18.4 → 0.18.5

package/dist/bedrock-source.d.ts

@@ -14,9 +14,13 @@ 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 advertises `web_search_tool_type: "text_and_image"` and sends
- * `search_content_types` on `{ type: "web_search" }`. Bedrock mantle accepts
- * the tool but rejects that field. Native OpenAI Responses is unchanged.
+ * 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;

package/dist/bedrock-source.js

@@ -15,27 +15,93 @@ export function isBedrockOpenAiModel(modelId) {
     return BEDROCK_OPENAI_MODEL.test(modelId);
 }
 /**
- * Codex advertises `web_search_tool_type: "text_and_image"` and sends
- * `search_content_types` on `{ type: "web_search" }`. Bedrock mantle accepts
- * the tool but rejects that field. Native OpenAI Responses is unchanged.
+ * 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 || !Array.isArray(payload.tools))
+    if (payload === undefined)
         return body;
+    let next = payload;
     let changed = false;
-    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;
+    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;
-        const { search_content_types: _ignored, ...rest } = entry;
-        return rest;
-    });
-    return changed ? { ...payload, tools } : body;
+    }
+    return changed ? next : item;
 }
 function mantleApiKey(env) {
     const key = env.AWS_BEARER_TOKEN_BEDROCK ?? env.BEDROCK_API_KEY;

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

@@ -523,6 +523,48 @@ test("sanitizeBedrockMantleRequestBody strips search_content_types from web_sear
     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({
@@ -551,6 +593,40 @@ test("Bedrock mantle Responses drops Codex search_content_types before egress",
         }
     ]);
 });
+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.4",
+  "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.4",
-    "@velum-labs/routekit-registry": "0.18.4",
-    "@velum-labs/routekit-runtime": "0.18.4",
-    "@velum-labs/routekit-tracing": "0.18.4"
+    "@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",