Merge Codex additional tools support

Author: gitcommit90

package-lock.json

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

package.json

@@ -38,14 +38,7 @@ function validateResponsesRequest(body) {
   if (body.max_output_tokens != null && (!Number.isInteger(body.max_output_tokens) || body.max_output_tokens < 1)) {
     throw invalid("max_output_tokens must be a positive integer", "max_output_tokens");
   }
-  if (Array.isArray(body.tools)) {
-    body.tools.forEach((tool, index) => {
-      if (!isObject(tool) || typeof tool.type !== "string") throw invalid("Each tool must be an object with a type", `tools[${index}]`);
-      if (tool.type === "function" && (typeof tool.name !== "string" || !tool.name)) {
-        throw invalid("Function tools require a name", `tools[${index}].name`);
-      }
-    });
-  }
+  if (Array.isArray(body.tools)) validateTools(body.tools, "tools");
   if (Array.isArray(body.input)) {
     body.input.forEach((item, index) => validateInputItem(item, `input[${index}]`));
   }
@@ -88,8 +81,22 @@ function reasoningItemsFromCall(call) {
   return Array.isArray(items) ? items.map(encryptedReasoningItem).filter(Boolean) : [];
 }
 
+function validateTools(tools, param) {
+  tools.forEach((tool, index) => {
+    if (!isObject(tool) || typeof tool.type !== "string") throw invalid("Each tool must be an object with a type", `${param}[${index}]`);
+    if (tool.type === "function" && (typeof tool.name !== "string" || !tool.name)) {
+      throw invalid("Function tools require a name", `${param}[${index}].name`);
+    }
+  });
+}
+
 function validateInputItem(item, param) {
   if (!isObject(item)) throw invalid("Input items must be objects", param);
+  if (item.type === "additional_tools") {
+    if (!Array.isArray(item.tools)) throw invalid("additional_tools tools must be an array", `${param}.tools`);
+    validateTools(item.tools, `${param}.tools`);
+    return;
+  }
   if (item.type === "reasoning") {
     if (item.encrypted_content != null && typeof item.encrypted_content !== "string") {
       throw invalid("reasoning encrypted_content must be a string or null", `${param}.encrypted_content`);
@@ -110,7 +117,7 @@ function validateInputItem(item, param) {
     if (!(typeof item.output === "string" || Array.isArray(item.output))) throw invalid("function_call_output requires string or array output", `${param}.output`);
     return;
   }
-  if (item.type !== "message" && !item.role) throw invalid("Unsupported input item", `${param}.type`);
+  if (item.type !== undefined && item.type !== "message") throw invalid("Unsupported input item", `${param}.type`);
   if (!["user", "assistant", "system", "developer"].includes(item.role)) throw invalid("Invalid message role", `${param}.role`);
   if (item.content == null) {
     if (item.role !== "assistant") throw invalid("Message content must be a string, content part, or array", `${param}.content`);
@@ -129,6 +136,7 @@ function inputMessages(input) {
   let pendingAssistant = null;
   let pendingReasoning = [];
   for (const item of input) {
+    if (item.type === "additional_tools") continue;
     if (item.type === "reasoning") {
       const reasoning = encryptedReasoningItem(item);
       if (reasoning) pendingReasoning.push(reasoning);
@@ -191,7 +199,11 @@ function toChatCompletionsBody(body) {
   const messages = inputMessages(body.input);
   if (body.instructions != null) messages.unshift({ role: "system", content: body.instructions });
   const out = { model: body.model, messages, stream: !!body.stream };
-  const tools = toChatTools(body.tools);
+  const declaredTools = [
+    ...(body.tools || []),
+    ...(Array.isArray(body.input) ? body.input.filter((item) => item.type === "additional_tools").flatMap((item) => item.tools) : []),
+  ];
+  const tools = toChatTools(declaredTools);
   if (tools) out.tools = tools;
   if (body.tool_choice !== undefined) out.tool_choice = toChatToolChoice(body.tool_choice);
   if (body.reasoning !== undefined) out.reasoning = { ...body.reasoning };

src/lib/responses-api.js

@@ -394,6 +394,56 @@ describe("gateway Responses API", () => {
     }
   });
 
+  it("routes Codex additional tools without a bogus message", 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_additional_tools",
+              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: "additional_tools",
+            role: "developer",
+            tools: [
+              { type: "custom", name: "shell", format: { type: "grammar", syntax: "lark", definition: "start: /.+/" } },
+              { type: "function", name: "read_file", parameters: { type: "object" } },
+            ],
+          }],
+          tools: [{ type: "namespace", name: "workspace", tools: [] }],
+        }),
+      });
+      assert.equal(response.status, 200);
+      assert.deepEqual(routedBody.messages, []);
+      assert.deepEqual(routedBody.tools.map((tool) => tool.type), ["namespace", "custom", "function"]);
+      assert.equal(routedBody.tools[1].format.definition, "start: /.+/");
+      assert.equal(routedBody.tools[2].function.name, "read_file");
+    } finally {
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+
   it("routes the live Codex singleton content payload", async () => {
     const store = createStore(tmpConfig());
     const apiKey = store.load().apiKey;

tests/gateway.test.js

@@ -183,6 +183,39 @@ describe("Responses API adapter", () => {
     assert.equal(body.max_output_tokens, 4096);
   });
 
+  it("merges Codex additional tools without creating a message", () => {
+    const grammar = { type: "grammar", syntax: "lark", definition: "start: /.+/" };
+    const body = toChatCompletionsBody({
+      model: "coding-route",
+      input: [
+        {
+          type: "additional_tools",
+          role: "developer",
+          tools: [
+            { type: "custom", name: "shell", description: "Run a command", format: grammar },
+            { type: "function", name: "read_file", parameters: { type: "object", properties: { path: { type: "string" } } } },
+          ],
+        },
+        { type: "message", role: "user", content: "Inspect it" },
+      ],
+      tools: [{ type: "namespace", name: "workspace", tools: [] }],
+    });
+
+    assert.deepEqual(body.messages, [{ role: "user", content: "Inspect it" }]);
+    assert.deepEqual(body.tools, [
+      { type: "namespace", name: "workspace", tools: [] },
+      { type: "custom", name: "shell", description: "Run a command", format: grammar },
+      { type: "function", function: { name: "read_file", parameters: { type: "object", properties: { path: { type: "string" } } } } },
+    ]);
+  });
+
+  it("does not let arbitrary role-bearing typed items bypass validation", () => {
+    assert.throws(
+      () => toChatCompletionsBody({ model: "route", input: [{ type: "unknown", role: "developer" }] }),
+      (error) => error.status === 400 && error.error.param === "input[0].type"
+    );
+  });
+
   it("accepts the live Codex singleton content payload", () => {
     const request = {
       model: "coding-route",