Merge Codex Responses content fix

Author: gitcommit90

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "rerouted",
-  "version": "0.4.13",
+  "version": "0.4.14",
   "description": "A macOS menu-bar router for accounts, models, and automatic fallback.",
   "author": "gitcommit90",
   "license": "MIT",

package.json

@@ -65,6 +65,13 @@ function validateContentPart(part, param) {
   }
 }
 
+function normalizeContentParts(value, param) {
+  if (Array.isArray(value)) return value;
+  if (!isObject(value)) return value;
+  validateContentPart(value, param);
+  return [value];
+}
+
 function encryptedReasoningItem(item) {
   if (!isObject(item) || item.type !== "reasoning" || typeof item.encrypted_content !== "string") return null;
   const copy = { type: "reasoning" };
@@ -84,9 +91,14 @@ function reasoningItemsFromCall(call) {
 function validateInputItem(item, param) {
   if (!isObject(item)) throw invalid("Input items must be objects", param);
   if (item.type === "reasoning") {
-    if (!encryptedReasoningItem(item)) throw invalid("reasoning requires encrypted_content", `${param}.encrypted_content`);
+    if (item.encrypted_content != null && typeof item.encrypted_content !== "string") {
+      throw invalid("reasoning encrypted_content must be a string or null", `${param}.encrypted_content`);
+    }
     return;
   }
+  if (item.type === "item_reference") {
+    throw invalid("item_reference is not supported by this stateless gateway; send the referenced item in input", param);
+  }
   if (item.type === "function_call") {
     if (typeof item.call_id !== "string" || !item.call_id) throw invalid("function_call requires call_id", `${param}.call_id`);
     if (typeof item.name !== "string" || !item.name) throw invalid("function_call requires name", `${param}.name`);
@@ -100,7 +112,14 @@ function validateInputItem(item, param) {
   }
   if (item.type !== "message" && !item.role) throw invalid("Unsupported input item", `${param}.type`);
   if (!["user", "assistant", "system", "developer"].includes(item.role)) throw invalid("Invalid message role", `${param}.role`);
-  if (!(typeof item.content === "string" || Array.isArray(item.content))) throw invalid("Message content must be a string or array", `${param}.content`);
+  if (item.content == null) {
+    if (item.role !== "assistant") throw invalid("Message content must be a string, content part, or array", `${param}.content`);
+    return;
+  }
+  item.content = normalizeContentParts(item.content, `${param}.content`);
+  if (!(typeof item.content === "string" || Array.isArray(item.content))) {
+    throw invalid("Message content must be a string, content part, or array", `${param}.content`);
+  }
   if (Array.isArray(item.content)) item.content.forEach((part, index) => validateContentPart(part, `${param}.content[${index}]`));
 }
 
@@ -111,7 +130,8 @@ function inputMessages(input) {
   let pendingReasoning = [];
   for (const item of input) {
     if (item.type === "reasoning") {
-      pendingReasoning.push(encryptedReasoningItem(item));
+      const reasoning = encryptedReasoningItem(item);
+      if (reasoning) pendingReasoning.push(reasoning);
       continue;
     }
     if (item.type === "function_call") {

src/lib/responses-api.js

@@ -394,6 +394,48 @@ describe("gateway Responses API", () => {
     }
   });
 
+  it("routes the live Codex singleton content payload", async () => {
+    const store = createStore(tmpConfig());
+    const apiKey = store.load().apiKey;
+    let routedBody;
+    const gateway = createGateway({
+      store,
+      router: {
+        async chatCompletions({ body }) {
+          routedBody = body;
+          return {
+            ok: true,
+            stream: false,
+            openAiJson: {
+              id: "chatcmpl_singleton",
+              choices: [{ message: { role: "assistant", content: "ok" }, finish_reason: "stop" }],
+            },
+          };
+        },
+      },
+    });
+    const server = http.createServer((req, res) => gateway.handle(req, res));
+    await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+
+    try {
+      const response = await fetch(`http://127.0.0.1:${server.address().port}/v1/responses`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: "route",
+          input: [{ type: "message", role: "user", content: { type: "input_text", text: "hello" } }],
+        }),
+      });
+      assert.equal(response.status, 200);
+      assert.deepEqual(routedBody.messages, [
+        { role: "user", content: [{ type: "text", text: "hello" }] },
+      ]);
+      assert.equal((await response.json()).output[0].content[0].text, "ok");
+    } finally {
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+
   it("returns Responses SSE and preserves router errors", async () => {
     const store = createStore(tmpConfig());
     const apiKey = store.load().apiKey;

tests/gateway.test.js

@@ -183,6 +183,58 @@ describe("Responses API adapter", () => {
     assert.equal(body.max_output_tokens, 4096);
   });
 
+  it("accepts the live Codex singleton content payload", () => {
+    const request = {
+      model: "coding-route",
+      input: [
+        { type: "message", role: "user", content: { type: "input_text", text: "hello" } },
+      ],
+    };
+    const body = toChatCompletionsBody(request);
+    assert.deepEqual(request.input[0].content, [{ type: "input_text", text: "hello" }]);
+    assert.deepEqual(body.messages, [{ role: "user", content: [{ type: "text", text: "hello" }] }]);
+  });
+
+  it("accepts supported singleton parts, empty assistant content, and nullable reasoning", () => {
+    const body = toChatCompletionsBody({
+      model: "route",
+      input: [
+        { type: "message", role: "user", content: { type: "input_image", image_url: "data:image/png;base64,QUJD" } },
+        { type: "message", role: "assistant", content: null },
+        { type: "message", role: "assistant" },
+        { type: "reasoning", id: "rs_unavailable", encrypted_content: null, summary: [] },
+        { type: "function_call", call_id: "call_1", name: "shell", arguments: "{}" },
+      ],
+    });
+    assert.equal(body.messages[0].content[0].type, "image_url");
+    assert.deepEqual(body.messages.slice(1, 3), [
+      { role: "assistant", content: null },
+      { role: "assistant", content: undefined },
+    ]);
+    assert.equal(body.messages[3].tool_calls[0].extra_content, undefined);
+  });
+
+  it("rejects arbitrary singleton objects and invalid adjacent shapes", () => {
+    for (const [content, param] of [
+      [{ foo: "bar" }, "input[0].content"],
+      [{ type: "input_text", text: 1 }, "input[0].content.text"],
+      [{ type: "unknown", text: "x" }, "input[0].content.type"],
+    ]) {
+      assert.throws(
+        () => toChatCompletionsBody({ model: "route", input: [{ type: "message", role: "user", content }] }),
+        (error) => error.status === 400 && error.error.param === param
+      );
+    }
+    assert.throws(
+      () => toChatCompletionsBody({ model: "route", input: [{ type: "message", role: "user", content: null }] }),
+      (error) => error.status === 400 && error.error.param === "input[0].content"
+    );
+    assert.throws(
+      () => toChatCompletionsBody({ model: "route", input: [{ type: "reasoning", encrypted_content: {} }] }),
+      (error) => error.status === 400 && error.error.param === "input[0].encrypted_content"
+    );
+  });
+
   it("rejects malformed input and stateless continuation IDs", () => {
     assert.throws(
       () => toChatCompletionsBody({ model: "route", input: [{ type: "function_call", name: "x", arguments: "{}" }] }),
@@ -192,6 +244,10 @@ describe("Responses API adapter", () => {
       () => toChatCompletionsBody({ model: "route", input: "hi", previous_response_id: "resp_prior" }),
       (error) => error.status === 400 && error.error.param === "previous_response_id"
     );
+    assert.throws(
+      () => toChatCompletionsBody({ model: "route", input: [{ type: "item_reference", id: "rs_prior" }] }),
+      (error) => error.status === 400 && error.error.param === "input[0]" && /stateless/.test(error.message)
+    );
   });
 
   it("preserves the requested route and marks length-limited responses incomplete", () => {