feat: native tool calling support across all protocols (#8)

* feat: native tool calling support across all protocols

- Fix 500 errors: wrap c.req.json() in try-catch for all 3 routes,
returning proper 400 responses for malformed JSON
- Forward tool definitions to Codex API instead of sending tools: []
- Parse function call SSE events (output_item.added,
function_call_arguments.delta/done) with item_id→call_id mapping
- Translate tool calls back to each protocol's format:
OpenAI: streaming tool_calls chunks + finish_reason "tool_calls"
Anthropic: tool_use content blocks + stop_reason "tool_use"
Gemini: functionCall parts in candidates
- Convert tool results from each protocol to native
function_call_output input items
- New shared module: tool-format.ts for cross-protocol tool conversion

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: address review issues in native tool calling

- Fix Gemini call_id collision: use counter-based IDs with name→callId
correlation instead of fragile fc_${name} pattern
- Remove dead code: pendingFunctionCalls (streaming Gemini),
toolCallArgsMap (non-streaming OpenAI & Anthropic)
- Fix Anthropic streaming text delta hardcoded index: use contentIndex
and reopen text block if text arrives after tool calls
- Unify GeminiPart type: add functionResponse to types/gemini.ts,
remove duplicate local type from gemini-to-codex.ts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: icebear0828 <icebear0828@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

src/proxy/codex-api.ts

@@ -27,6 +27,8 @@ export interface CodexResponsesRequest {
   reasoning?: { effort: string };
   /** Optional: tools available to the model */
   tools?: unknown[];
+  /** Optional: tool choice strategy */
+  tool_choice?: string | { type: string; name: string };
   /** Optional: previous response ID for multi-turn */
   previous_response_id?: string | null;
 }
@@ -34,7 +36,9 @@ export interface CodexResponsesRequest {
 export type CodexInputItem =
   | { role: "user"; content: string }
   | { role: "assistant"; content: string }
-  | { role: "system"; content: string };
+  | { role: "system"; content: string }
+  | { type: "function_call"; id?: string; call_id: string; name: string; arguments: string }
+  | { type: "function_call_output"; call_id: string; output: string };
 
 /** Parsed SSE event from the Codex Responses stream */
 export interface CodexSSEEvent {

src/routes/chat.ts

@@ -103,7 +103,6 @@ export function createChatRoutes(
         },
       });
     }
-
     const parsed = ChatCompletionRequestSchema.safeParse(body);
     if (!parsed.success) {
       c.status(400);

src/routes/gemini.ts

@@ -127,7 +127,13 @@ export function createGeminiRoutes(
     }
 
     // Parse request
-    const body = await c.req.json();
+    let body: unknown;
+    try {
+      body = await c.req.json();
+    } catch {
+      c.status(400);
+      return c.json(makeError(400, "Invalid JSON in request body"));
+    }
     const validationResult = GeminiGenerateContentRequestSchema.safeParse(body);
     if (!validationResult.success) {
       c.status(400);

src/routes/messages.ts

@@ -86,7 +86,15 @@ export function createMessagesRoutes(
     }
 
     // Parse request
-    const body = await c.req.json();
+    let body: unknown;
+    try {
+      body = await c.req.json();
+    } catch {
+      c.status(400);
+      return c.json(
+        makeError("invalid_request_error", "Invalid JSON in request body"),
+      );
+    }
     const parsed = AnthropicMessagesRequestSchema.safeParse(body);
     if (!parsed.success) {
       c.status(400);

src/translation/anthropic-to-codex.ts

@@ -10,6 +10,7 @@ import type {
 import { resolveModelId, getModelInfo } from "../routes/models.js";
 import { getConfig } from "../config.js";
 import { buildInstructions, budgetToEffort } from "./shared-utils.js";
+import { anthropicToolsToCodex, anthropicToolChoiceToCodex } from "./tool-format.js";
 
 /**
  * Map Anthropic thinking budget_tokens to Codex reasoning effort.
@@ -22,43 +23,77 @@ function mapThinkingToEffort(
 }
 
 /**
- * Extract text from Anthropic content (string or content block array).
- * Flattens tool_use/tool_result blocks into readable text for Codex.
+ * Extract text-only content from Anthropic blocks.
  */
-function flattenContent(
+function extractTextContent(
   content: string | Array<Record<string, unknown>>,
 ): string {
   if (typeof content === "string") return content;
-  const parts: string[] = [];
+  return content
+    .filter((b) => b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text as string)
+    .join("\n");
+}
+
+/**
+ * Convert Anthropic message content blocks into native Codex input items.
+ * Handles text, tool_use, and tool_result blocks.
+ */
+function contentToInputItems(
+  role: "user" | "assistant",
+  content: string | Array<Record<string, unknown>>,
+): CodexInputItem[] {
+  if (typeof content === "string") {
+    return [{ role, content }];
+  }
+
+  const items: CodexInputItem[] = [];
+
+  // Collect text blocks first
+  const text = extractTextContent(content);
+  if (text || !content.some((b) => b.type === "tool_use" || b.type === "tool_result")) {
+    items.push({ role, content: text });
+  }
+
   for (const block of content) {
-    if (block.type === "text" && typeof block.text === "string") {
-      parts.push(block.text);
-    } else if (block.type === "tool_use") {
+    if (block.type === "tool_use") {
       const name = typeof block.name === "string" ? block.name : "unknown";
-      let inputStr: string;
+      const id = typeof block.id === "string" ? block.id : `tc_${name}`;
+      let args: string;
       try {
-        inputStr = JSON.stringify(block.input, null, 2);
+        args = JSON.stringify(block.input ?? {});
       } catch {
-        inputStr = String(block.input);
+        args = "{}";
       }
-      parts.push(`[Tool Call: ${name}(${inputStr})]`);
+      items.push({
+        type: "function_call",
+        call_id: id,
+        name,
+        arguments: args,
+      });
     } else if (block.type === "tool_result") {
-      const id =
-        typeof block.tool_use_id === "string" ? block.tool_use_id : "unknown";
-      let text = "";
+      const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "unknown";
+      let resultText = "";
       if (typeof block.content === "string") {
-        text = block.content;
+        resultText = block.content;
       } else if (Array.isArray(block.content)) {
-        text = (block.content as Array<{ text?: string }>)
+        resultText = (block.content as Array<{ text?: string }>)
           .filter((b) => typeof b.text === "string")
           .map((b) => b.text!)
           .join("\n");
       }
-      const prefix = block.is_error ? "Tool Error" : "Tool Result";
-      parts.push(`[${prefix} (${id})]: ${text}`);
+      if (block.is_error) {
+        resultText = `Error: ${resultText}`;
+      }
+      items.push({
+        type: "function_call_output",
+        call_id: toolUseId,
+        output: resultText,
+      });
     }
   }
-  return parts.join("\n");
+
+  return items;
 }
 
 /**
@@ -90,10 +125,11 @@ export function translateAnthropicToCodexRequest(
   // Build input items from messages
   const input: CodexInputItem[] = [];
   for (const msg of req.messages) {
-    input.push({
-      role: msg.role as "user" | "assistant",
-      content: flattenContent(msg.content),
-    });
+    const items = contentToInputItems(
+      msg.role as "user" | "assistant",
+      msg.content as string | Array<Record<string, unknown>>,
+    );
+    input.push(...items);
   }
 
   // Ensure at least one input message
@@ -106,6 +142,10 @@ export function translateAnthropicToCodexRequest(
   const modelInfo = getModelInfo(modelId);
   const config = getConfig();
 
+  // Convert tools to Codex format
+  const codexTools = req.tools?.length ? anthropicToolsToCodex(req.tools) : [];
+  const codexToolChoice = anthropicToolChoiceToCodex(req.tool_choice);
+
   // Build request
   const request: CodexResponsesRequest = {
     model: modelId,
@@ -113,9 +153,14 @@ export function translateAnthropicToCodexRequest(
     input,
     stream: true,
     store: false,
-    tools: [],
+    tools: codexTools,
   };
 
+  // Add tool_choice if specified
+  if (codexToolChoice) {
+    request.tool_choice = codexToolChoice;
+  }
+
   // Add previous response ID for multi-turn conversations
   if (previousResponseId) {
     request.previous_response_id = previousResponseId;

src/translation/codex-event-extractor.ts

@@ -16,11 +16,31 @@ export interface UsageInfo {
   output_tokens: number;
 }
 
+export interface FunctionCallStart {
+  callId: string;
+  name: string;
+  outputIndex: number;
+}
+
+export interface FunctionCallDelta {
+  callId: string;
+  delta: string;
+}
+
+export interface FunctionCallDone {
+  callId: string;
+  name: string;
+  arguments: string;
+}
+
 export interface ExtractedEvent {
   typed: TypedCodexEvent;
   responseId?: string;
   textDelta?: string;
   usage?: UsageInfo;
+  functionCallStart?: FunctionCallStart;
+  functionCallDelta?: FunctionCallDelta;
+  functionCallDone?: FunctionCallDone;
 }
 
 /**
@@ -31,6 +51,9 @@ export async function* iterateCodexEvents(
   codexApi: CodexApi,
   rawResponse: Response,
 ): AsyncGenerator<ExtractedEvent> {
+  // Map item_id → { call_id, name } for resolving delta/done events
+  const itemIdToCallInfo = new Map<string, { callId: string; name: string }>();
+
   for await (const raw of codexApi.parseStream(rawResponse)) {
     const typed = parseCodexEvent(raw);
     const extracted: ExtractedEvent = { typed };
@@ -45,6 +68,42 @@ export async function* iterateCodexEvents(
         extracted.textDelta = typed.delta;
         break;
 
+      case "response.output_item.added":
+        if (typed.item.type === "function_call") {
+          // Register item_id → call_id mapping
+          itemIdToCallInfo.set(typed.item.id, {
+            callId: typed.item.call_id,
+            name: typed.item.name,
+          });
+          extracted.functionCallStart = {
+            callId: typed.item.call_id,
+            name: typed.item.name,
+            outputIndex: typed.outputIndex,
+          };
+        }
+        break;
+
+      case "response.function_call_arguments.delta": {
+        // Resolve item_id to call_id if needed
+        const deltaInfo = itemIdToCallInfo.get(typed.call_id);
+        extracted.functionCallDelta = {
+          callId: deltaInfo?.callId ?? typed.call_id,
+          delta: typed.delta,
+        };
+        break;
+      }
+
+      case "response.function_call_arguments.done": {
+        // Resolve item_id to call_id + name if needed
+        const doneInfo = itemIdToCallInfo.get(typed.call_id);
+        extracted.functionCallDone = {
+          callId: doneInfo?.callId ?? typed.call_id,
+          name: typed.name || doneInfo?.name || "",
+          arguments: typed.arguments,
+        };
+        break;
+      }
+
       case "response.completed":
         if (typed.response.id) extracted.responseId = typed.response.id;
         if (typed.response.usage) extracted.usage = typed.response.usage;

src/translation/codex-to-anthropic.ts

@@ -12,6 +12,7 @@
 import { randomUUID } from "crypto";
 import type { CodexApi } from "../proxy/codex-api.js";
 import type {
+  AnthropicContentBlock,
   AnthropicMessagesResponse,
   AnthropicUsage,
 } from "../types/anthropic.js";
@@ -41,6 +42,10 @@ export async function* streamCodexToAnthropic(
   const msgId = `msg_${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   let outputTokens = 0;
   let inputTokens = 0;
+  let hasToolCalls = false;
+  let contentIndex = 0;
+  let textBlockStarted = false;
+  const callIdsWithDeltas = new Set<string>();
 
   // 1. message_start
   yield formatSSE("message_start", {
@@ -60,20 +65,86 @@ export async function* streamCodexToAnthropic(
   // 2. content_block_start for text block at index 0
   yield formatSSE("content_block_start", {
     type: "content_block_start",
-    index: 0,
+    index: contentIndex,
     content_block: { type: "text", text: "" },
   });
+  textBlockStarted = true;
 
   // 3. Process Codex stream events
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Handle function call start → close text block, open tool_use block
+    if (evt.functionCallStart) {
+      hasToolCalls = true;
+
+      // Close text block if still open
+      if (textBlockStarted) {
+        yield formatSSE("content_block_stop", {
+          type: "content_block_stop",
+          index: contentIndex,
+        });
+        contentIndex++;
+        textBlockStarted = false;
+      }
+
+      // Start tool_use block
+      yield formatSSE("content_block_start", {
+        type: "content_block_start",
+        index: contentIndex,
+        content_block: {
+          type: "tool_use",
+          id: evt.functionCallStart.callId,
+          name: evt.functionCallStart.name,
+          input: {},
+        },
+      });
+      continue;
+    }
+
+    if (evt.functionCallDelta) {
+      callIdsWithDeltas.add(evt.functionCallDelta.callId);
+      yield formatSSE("content_block_delta", {
+        type: "content_block_delta",
+        index: contentIndex,
+        delta: { type: "input_json_delta", partial_json: evt.functionCallDelta.delta },
+      });
+      continue;
+    }
+
+    if (evt.functionCallDone) {
+      // Emit full arguments if no deltas were streamed
+      if (!callIdsWithDeltas.has(evt.functionCallDone.callId)) {
+        yield formatSSE("content_block_delta", {
+          type: "content_block_delta",
+          index: contentIndex,
+          delta: { type: "input_json_delta", partial_json: evt.functionCallDone.arguments },
+        });
+      }
+      // Close this tool_use block
+      yield formatSSE("content_block_stop", {
+        type: "content_block_stop",
+        index: contentIndex,
+      });
+      contentIndex++;
+      continue;
+    }
+
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
+          // Reopen a text block if the previous one was closed (e.g. after tool calls)
+          if (!textBlockStarted) {
+            yield formatSSE("content_block_start", {
+              type: "content_block_start",
+              index: contentIndex,
+              content_block: { type: "text", text: "" },
+            });
+            textBlockStarted = true;
+          }
           yield formatSSE("content_block_delta", {
             type: "content_block_delta",
-            index: 0,
+            index: contentIndex,
             delta: { type: "text_delta", text: evt.textDelta },
           });
         }
@@ -91,16 +162,18 @@ export async function* streamCodexToAnthropic(
     }
   }
 
-  // 4. content_block_stop
-  yield formatSSE("content_block_stop", {
-    type: "content_block_stop",
-    index: 0,
-  });
+  // 4. Close text block if still open (no tool calls, or text came before tools)
+  if (textBlockStarted) {
+    yield formatSSE("content_block_stop", {
+      type: "content_block_stop",
+      index: contentIndex,
+    });
+  }
 
   // 5. message_delta with stop_reason and usage
   yield formatSSE("message_delta", {
     type: "message_delta",
-    delta: { stop_reason: "end_turn" },
+    delta: { stop_reason: hasToolCalls ? "tool_use" : "end_turn" },
     usage: { output_tokens: outputTokens },
   });
 
@@ -129,6 +202,9 @@ export async function collectCodexToAnthropicResponse(
   let outputTokens = 0;
   let responseId: string | null = null;
 
+  // Collect tool calls
+  const toolUseBlocks: AnthropicContentBlock[] = [];
+
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
     if (evt.textDelta) fullText += evt.textDelta;
@@ -136,6 +212,29 @@ export async function collectCodexToAnthropicResponse(
       inputTokens = evt.usage.input_tokens;
       outputTokens = evt.usage.output_tokens;
     }
+    if (evt.functionCallDone) {
+      let parsedInput: Record<string, unknown> = {};
+      try {
+        parsedInput = JSON.parse(evt.functionCallDone.arguments) as Record<string, unknown>;
+      } catch { /* use empty object */ }
+      toolUseBlocks.push({
+        type: "tool_use",
+        id: evt.functionCallDone.callId,
+        name: evt.functionCallDone.name,
+        input: parsedInput,
+      });
+    }
+  }
+
+  const hasToolCalls = toolUseBlocks.length > 0;
+  const content: AnthropicContentBlock[] = [];
+  if (fullText) {
+    content.push({ type: "text", text: fullText });
+  }
+  content.push(...toolUseBlocks);
+  // Ensure at least one content block
+  if (content.length === 0) {
+    content.push({ type: "text", text: "" });
   }
 
   const usage: AnthropicUsage = {
@@ -148,9 +247,9 @@ export async function collectCodexToAnthropicResponse(
       id,
       type: "message",
       role: "assistant",
-      content: [{ type: "text", text: fullText }],
+      content,
       model,
-      stop_reason: "end_turn",
+      stop_reason: hasToolCalls ? "tool_use" : "end_turn",
       stop_sequence: null,
       usage,
     },

src/translation/codex-to-gemini.ts

@@ -13,6 +13,7 @@ import type { CodexApi } from "../proxy/codex-api.js";
 import type {
   GeminiGenerateContentResponse,
   GeminiUsageMetadata,
+  GeminiPart,
 } from "../types/gemini.js";
 import { iterateCodexEvents } from "./codex-event-extractor.js";
 
@@ -38,6 +39,33 @@ export async function* streamCodexToGemini(
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Function call done → emit as a candidate with functionCall part
+    if (evt.functionCallDone) {
+      let args: Record<string, unknown> = {};
+      try {
+        args = JSON.parse(evt.functionCallDone.arguments) as Record<string, unknown>;
+      } catch { /* use empty args */ }
+      const fcChunk: GeminiGenerateContentResponse = {
+        candidates: [
+          {
+            content: {
+              parts: [{
+                functionCall: {
+                  name: evt.functionCallDone.name,
+                  args,
+                },
+              }],
+              role: "model",
+            },
+            index: 0,
+          },
+        ],
+        modelVersion: model,
+      };
+      yield `data: ${JSON.stringify(fcChunk)}\n\n`;
+      continue;
+    }
+
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
@@ -108,6 +136,7 @@ export async function collectCodexToGeminiResponse(
   let inputTokens = 0;
   let outputTokens = 0;
   let responseId: string | null = null;
+  const functionCallParts: GeminiPart[] = [];
 
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
@@ -116,6 +145,15 @@ export async function collectCodexToGeminiResponse(
       inputTokens = evt.usage.input_tokens;
       outputTokens = evt.usage.output_tokens;
     }
+    if (evt.functionCallDone) {
+      let args: Record<string, unknown> = {};
+      try {
+        args = JSON.parse(evt.functionCallDone.arguments) as Record<string, unknown>;
+      } catch { /* use empty args */ }
+      functionCallParts.push({
+        functionCall: { name: evt.functionCallDone.name, args },
+      });
+    }
   }
 
   const usage: GeminiUsageInfo = {
@@ -129,12 +167,22 @@ export async function collectCodexToGeminiResponse(
     totalTokenCount: inputTokens + outputTokens,
   };
 
+  // Build response parts: text + function calls
+  const parts: GeminiPart[] = [];
+  if (fullText) {
+    parts.push({ text: fullText });
+  }
+  parts.push(...functionCallParts);
+  if (parts.length === 0) {
+    parts.push({ text: "" });
+  }
+
   return {
     response: {
       candidates: [
         {
           content: {
-            parts: [{ text: fullText }],
+            parts,
             role: "model",
           },
           finishReason: "STOP",

src/translation/codex-to-openai.ts

@@ -15,6 +15,8 @@ import type { CodexApi } from "../proxy/codex-api.js";
 import type {
   ChatCompletionResponse,
   ChatCompletionChunk,
+  ChatCompletionToolCall,
+  ChatCompletionChunkToolCall,
 } from "../types/openai.js";
 import { iterateCodexEvents, type UsageInfo } from "./codex-event-extractor.js";
 
@@ -39,6 +41,12 @@ export async function* streamCodexToOpenAI(
 ): AsyncGenerator<string> {
   const chunkId = `chatcmpl-${randomUUID().replace(/-/g, "").slice(0, 24)}`;
   const created = Math.floor(Date.now() / 1000);
+  let hasToolCalls = false;
+  // Track tool call indices by call_id
+  const toolCallIndexMap = new Map<string, number>();
+  let nextToolCallIndex = 0;
+  // Track which call_ids have received argument deltas
+  const callIdsWithDeltas = new Set<string>();
 
   // Send initial role chunk
   yield formatSSE({
@@ -58,6 +66,88 @@ export async function* streamCodexToOpenAI(
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) onResponseId?.(evt.responseId);
 
+    // Handle function call events
+    if (evt.functionCallStart) {
+      hasToolCalls = true;
+      const idx = nextToolCallIndex++;
+      toolCallIndexMap.set(evt.functionCallStart.callId, idx);
+      const toolCall: ChatCompletionChunkToolCall = {
+        index: idx,
+        id: evt.functionCallStart.callId,
+        type: "function",
+        function: {
+          name: evt.functionCallStart.name,
+          arguments: "",
+        },
+      };
+      yield formatSSE({
+        id: chunkId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: { tool_calls: [toolCall] },
+            finish_reason: null,
+          },
+        ],
+      });
+      continue;
+    }
+
+    if (evt.functionCallDelta) {
+      callIdsWithDeltas.add(evt.functionCallDelta.callId);
+      const idx = toolCallIndexMap.get(evt.functionCallDelta.callId) ?? 0;
+      const toolCall: ChatCompletionChunkToolCall = {
+        index: idx,
+        function: {
+          arguments: evt.functionCallDelta.delta,
+        },
+      };
+      yield formatSSE({
+        id: chunkId,
+        object: "chat.completion.chunk",
+        created,
+        model,
+        choices: [
+          {
+            index: 0,
+            delta: { tool_calls: [toolCall] },
+            finish_reason: null,
+          },
+        ],
+      });
+      continue;
+    }
+
+    // functionCallDone — emit full arguments if no deltas were streamed
+    if (evt.functionCallDone) {
+      if (!callIdsWithDeltas.has(evt.functionCallDone.callId)) {
+        const idx = toolCallIndexMap.get(evt.functionCallDone.callId) ?? 0;
+        const toolCall: ChatCompletionChunkToolCall = {
+          index: idx,
+          function: {
+            arguments: evt.functionCallDone.arguments,
+          },
+        };
+        yield formatSSE({
+          id: chunkId,
+          object: "chat.completion.chunk",
+          created,
+          model,
+          choices: [
+            {
+              index: 0,
+              delta: { tool_calls: [toolCall] },
+              finish_reason: null,
+            },
+          ],
+        });
+      }
+      continue;
+    }
+
     switch (evt.typed.type) {
       case "response.output_text.delta": {
         if (evt.textDelta) {
@@ -89,7 +179,7 @@ export async function* streamCodexToOpenAI(
             {
               index: 0,
               delta: {},
-              finish_reason: "stop",
+              finish_reason: hasToolCalls ? "tool_calls" : "stop",
             },
           ],
         });
@@ -118,6 +208,9 @@ export async function collectCodexResponse(
   let completionTokens = 0;
   let responseId: string | null = null;
 
+  // Collect tool calls
+  const toolCalls: ChatCompletionToolCall[] = [];
+
   for await (const evt of iterateCodexEvents(codexApi, rawResponse)) {
     if (evt.responseId) responseId = evt.responseId;
     if (evt.textDelta) fullText += evt.textDelta;
@@ -125,6 +218,25 @@ export async function collectCodexResponse(
       promptTokens = evt.usage.input_tokens;
       completionTokens = evt.usage.output_tokens;
     }
+    if (evt.functionCallDone) {
+      toolCalls.push({
+        id: evt.functionCallDone.callId,
+        type: "function",
+        function: {
+          name: evt.functionCallDone.name,
+          arguments: evt.functionCallDone.arguments,
+        },
+      });
+    }
+  }
+
+  const hasToolCalls = toolCalls.length > 0;
+  const message: ChatCompletionResponse["choices"][0]["message"] = {
+    role: "assistant",
+    content: fullText || null,
+  };
+  if (hasToolCalls) {
+    message.tool_calls = toolCalls;
   }
 
   return {
@@ -136,11 +248,8 @@ export async function collectCodexResponse(
       choices: [
         {
           index: 0,
-          message: {
-            role: "assistant",
-            content: fullText,
-          },
-          finish_reason: "stop",
+          message,
+          finish_reason: hasToolCalls ? "tool_calls" : "stop",
         },
       ],
       usage: {

src/translation/gemini-to-codex.ts

@@ -5,6 +5,7 @@
 import type {
   GeminiGenerateContentRequest,
   GeminiContent,
+  GeminiPart,
 } from "../types/gemini.js";
 import type {
   CodexResponsesRequest,
@@ -13,43 +14,83 @@ import type {
 import { resolveModelId, getModelInfo } from "../routes/models.js";
 import { getConfig } from "../config.js";
 import { buildInstructions, budgetToEffort } from "./shared-utils.js";
+import { geminiToolsToCodex, geminiToolConfigToCodex } from "./tool-format.js";
 
 /**
- * Extract text from Gemini content parts.
- * Flattens functionCall/functionResponse parts into readable text for Codex.
+ * Extract text-only content from Gemini parts.
  */
-function flattenParts(
-  parts: Array<{
-    text?: string;
-    thought?: boolean;
-    functionCall?: { name: string; args?: Record<string, unknown> };
-    functionResponse?: { name: string; response?: Record<string, unknown> };
-  }>,
-): string {
-  const textParts: string[] = [];
+function extractTextFromParts(parts: GeminiPart[]): string {
+  return parts
+    .filter((p) => !p.thought && p.text)
+    .map((p) => p.text!)
+    .join("\n");
+}
+
+/**
+ * Convert Gemini content parts into native Codex input items.
+ */
+function partsToInputItems(
+  role: "user" | "assistant",
+  parts: GeminiPart[],
+): CodexInputItem[] {
+  const items: CodexInputItem[] = [];
+  const hasFunctionParts = parts.some((p) => p.functionCall || p.functionResponse);
+
+  // Collect text content
+  const text = extractTextFromParts(parts);
+  if (text || !hasFunctionParts) {
+    items.push({ role, content: text });
+  }
+
+  // Track call_ids by function name to correlate functionCall → functionResponse
+  let callCounter = 0;
+  const nameToCallIds = new Map<string, string[]>();
+
   for (const p of parts) {
-    if (p.thought) continue;
-    if (p.text) {
-      textParts.push(p.text);
-    } else if (p.functionCall) {
+    if (p.functionCall) {
+      const callId = `fc_${callCounter++}`;
       let args: string;
       try {
-        args = JSON.stringify(p.functionCall.args ?? {}, null, 2);
+        args = JSON.stringify(p.functionCall.args ?? {});
       } catch {
-        args = String(p.functionCall.args);
+        args = "{}";
       }
-      textParts.push(`[Tool Call: ${p.functionCall.name}(${args})]`);
+      items.push({
+        type: "function_call",
+        call_id: callId,
+        name: p.functionCall.name,
+        arguments: args,
+      });
+      // Record call_id for this function name (for matching responses)
+      const ids = nameToCallIds.get(p.functionCall.name) ?? [];
+      ids.push(callId);
+      nameToCallIds.set(p.functionCall.name, ids);
     } else if (p.functionResponse) {
-      let resp: string;
+      let output: string;
       try {
-        resp = JSON.stringify(p.functionResponse.response ?? {}, null, 2);
+        output = JSON.stringify(p.functionResponse.response ?? {});
       } catch {
-        resp = String(p.functionResponse.response);
+        output = String(p.functionResponse.response);
       }
-      textParts.push(`[Tool Result (${p.functionResponse.name})]: ${resp}`);
+      // Match response to the earliest unmatched call with the same name
+      const ids = nameToCallIds.get(p.functionResponse.name);
+      const callId = ids?.shift() ?? `fc_${callCounter++}`;
+      items.push({
+        type: "function_call_output",
+        call_id: callId,
+        output,
+      });
     }
   }
-  return textParts.join("\n");
+
+  return items;
+}
+
+/**
+ * Extract text from Gemini content parts (for session hashing).
+ */
+function flattenParts(parts: GeminiPart[]): string {
+  return extractTextFromParts(parts);
 }
 
 /**
@@ -103,10 +144,11 @@ export function translateGeminiToCodexRequest(
   const input: CodexInputItem[] = [];
   for (const content of req.contents) {
     const role = content.role === "model" ? "assistant" : "user";
-    input.push({
-      role: role as "user" | "assistant",
-      content: flattenParts(content.parts),
-    });
+    const items = partsToInputItems(
+      role as "user" | "assistant",
+      content.parts as GeminiPart[],
+    );
+    input.push(...items);
   }
 
   // Ensure at least one input message
@@ -119,6 +161,10 @@ export function translateGeminiToCodexRequest(
   const modelInfo = getModelInfo(modelId);
   const config = getConfig();
 
+  // Convert tools to Codex format
+  const codexTools = req.tools?.length ? geminiToolsToCodex(req.tools) : [];
+  const codexToolChoice = geminiToolConfigToCodex(req.toolConfig);
+
   // Build request
   const request: CodexResponsesRequest = {
     model: modelId,
@@ -126,9 +172,14 @@ export function translateGeminiToCodexRequest(
     input,
     stream: true,
     store: false,
-    tools: [],
+    tools: codexTools,
   };
 
+  // Add tool_choice if specified
+  if (codexToolChoice) {
+    request.tool_choice = codexToolChoice;
+  }
+
   // Add previous response ID for multi-turn conversations
   if (previousResponseId) {
     request.previous_response_id = previousResponseId;

src/translation/openai-to-codex.ts

@@ -10,6 +10,11 @@ import type {
 import { resolveModelId, getModelInfo } from "../routes/models.js";
 import { getConfig } from "../config.js";
 import { buildInstructions } from "./shared-utils.js";
+import {
+  openAIToolsToCodex,
+  openAIToolChoiceToCodex,
+  openAIFunctionsToCodex,
+} from "./tool-format.js";
 
 /** Extract plain text from content (string, array, null, or undefined). */
 function extractText(content: ChatMessage["content"]): string {
@@ -21,35 +26,6 @@ function extractText(content: ChatMessage["content"]): string {
     .join("\n");
 }
 
-/** Flatten tool_calls array into human-readable text. */
-function flattenToolCalls(
-  toolCalls: NonNullable<ChatMessage["tool_calls"]>,
-): string {
-  return toolCalls
-    .map((tc) => {
-      let args = tc.function.arguments;
-      try {
-        args = JSON.stringify(JSON.parse(args), null, 2);
-      } catch {
-        /* keep raw string */
-      }
-      return `[Tool Call: ${tc.function.name}(${args})]`;
-    })
-    .join("\n");
-}
-
-/** Flatten a legacy function_call into human-readable text. */
-function flattenFunctionCall(
-  fc: NonNullable<ChatMessage["function_call"]>,
-): string {
-  let args = fc.arguments;
-  try {
-    args = JSON.stringify(JSON.parse(args), null, 2);
-  } catch {
-    /* keep raw string */
-  }
-  return `[Tool Call: ${fc.name}(${args})]`;
-}
 
 /**
  * Convert a ChatCompletionRequest to a CodexResponsesRequest.
@@ -80,23 +56,43 @@ export function translateToCodexRequest(
     if (msg.role === "system" || msg.role === "developer") continue;
 
     if (msg.role === "assistant") {
-      const parts: string[] = [];
+      // First push the text content
       const text = extractText(msg.content);
-      if (text) parts.push(text);
-      if (msg.tool_calls?.length) parts.push(flattenToolCalls(msg.tool_calls));
-      if (msg.function_call) parts.push(flattenFunctionCall(msg.function_call));
-      input.push({ role: "assistant", content: parts.join("\n") });
+      if (text || (!msg.tool_calls?.length && !msg.function_call)) {
+        input.push({ role: "assistant", content: text });
+      }
+      // Then push tool calls as native function_call items
+      if (msg.tool_calls?.length) {
+        for (const tc of msg.tool_calls) {
+          input.push({
+            type: "function_call",
+            call_id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+          });
+        }
+      }
+      if (msg.function_call) {
+        input.push({
+          type: "function_call",
+          call_id: `fc_${msg.function_call.name}`,
+          name: msg.function_call.name,
+          arguments: msg.function_call.arguments,
+        });
+      }
     } else if (msg.role === "tool") {
-      const name = msg.name ?? msg.tool_call_id ?? "unknown";
+      // Native tool result
       input.push({
-        role: "user",
-        content: `[Tool Result (${name})]: ${extractText(msg.content)}`,
+        type: "function_call_output",
+        call_id: msg.tool_call_id ?? "unknown",
+        output: extractText(msg.content),
       });
     } else if (msg.role === "function") {
-      const name = msg.name ?? "unknown";
+      // Legacy function result → native format
       input.push({
-        role: "user",
-        content: `[Tool Result (${name})]: ${extractText(msg.content)}`,
+        type: "function_call_output",
+        call_id: `fc_${msg.name ?? "unknown"}`,
+        output: extractText(msg.content),
       });
     } else {
       input.push({ role: "user", content: extractText(msg.content) });
@@ -113,6 +109,14 @@ export function translateToCodexRequest(
   const modelInfo = getModelInfo(modelId);
   const config = getConfig();
 
+  // Convert tools to Codex format
+  const codexTools = req.tools?.length
+    ? openAIToolsToCodex(req.tools)
+    : req.functions?.length
+      ? openAIFunctionsToCodex(req.functions)
+      : [];
+  const codexToolChoice = openAIToolChoiceToCodex(req.tool_choice);
+
   // Build request
   const request: CodexResponsesRequest = {
     model: modelId,
@@ -120,9 +124,14 @@ export function translateToCodexRequest(
     input,
     stream: true,
     store: false,
-    tools: [],
+    tools: codexTools,
   };
 
+  // Add tool_choice if specified
+  if (codexToolChoice) {
+    request.tool_choice = codexToolChoice;
+  }
+
   // Add previous response ID for multi-turn conversations
   if (previousResponseId) {
     request.previous_response_id = previousResponseId;

src/translation/tool-format.ts

@@ -0,0 +1,135 @@
+/**
+ * Shared tool format conversion utilities.
+ *
+ * Converts tool definitions and tool_choice from each protocol
+ * (OpenAI, Anthropic, Gemini) into the Codex Responses API format.
+ */
+
+import type { ChatCompletionRequest } from "../types/openai.js";
+import type { AnthropicMessagesRequest } from "../types/anthropic.js";
+import type { GeminiGenerateContentRequest } from "../types/gemini.js";
+
+// ── Codex Responses API tool format ─────────────────────────────
+
+export interface CodexToolDefinition {
+  type: "function";
+  name: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+  strict?: boolean;
+}
+
+// ── OpenAI → Codex ──────────────────────────────────────────────
+
+export function openAIToolsToCodex(
+  tools: NonNullable<ChatCompletionRequest["tools"]>,
+): CodexToolDefinition[] {
+  return tools.map((t) => {
+    const def: CodexToolDefinition = {
+      type: "function",
+      name: t.function.name,
+    };
+    if (t.function.description) def.description = t.function.description;
+    if (t.function.parameters) def.parameters = t.function.parameters;
+    return def;
+  });
+}
+
+export function openAIToolChoiceToCodex(
+  choice: ChatCompletionRequest["tool_choice"],
+): string | { type: "function"; name: string } | undefined {
+  if (!choice) return undefined;
+  if (typeof choice === "string") {
+    // "none" | "auto" | "required" → pass through
+    return choice;
+  }
+  // { type: "function", function: { name } } → { type: "function", name }
+  return { type: "function", name: choice.function.name };
+}
+
+/**
+ * Convert legacy OpenAI `functions` array to Codex tool definitions.
+ */
+export function openAIFunctionsToCodex(
+  functions: NonNullable<ChatCompletionRequest["functions"]>,
+): CodexToolDefinition[] {
+  return functions.map((f) => {
+    const def: CodexToolDefinition = {
+      type: "function",
+      name: f.name,
+    };
+    if (f.description) def.description = f.description;
+    if (f.parameters) def.parameters = f.parameters;
+    return def;
+  });
+}
+
+// ── Anthropic → Codex ───────────────────────────────────────────
+
+export function anthropicToolsToCodex(
+  tools: NonNullable<AnthropicMessagesRequest["tools"]>,
+): CodexToolDefinition[] {
+  return tools.map((t) => {
+    const def: CodexToolDefinition = {
+      type: "function",
+      name: t.name,
+    };
+    if (t.description) def.description = t.description;
+    if (t.input_schema) def.parameters = t.input_schema;
+    return def;
+  });
+}
+
+export function anthropicToolChoiceToCodex(
+  choice: AnthropicMessagesRequest["tool_choice"],
+): string | { type: "function"; name: string } | undefined {
+  if (!choice) return undefined;
+  switch (choice.type) {
+    case "auto":
+      return "auto";
+    case "any":
+      return "required";
+    case "tool":
+      return { type: "function", name: choice.name };
+    default:
+      return undefined;
+  }
+}
+
+// ── Gemini → Codex ──────────────────────────────────────────────
+
+export function geminiToolsToCodex(
+  tools: NonNullable<GeminiGenerateContentRequest["tools"]>,
+): CodexToolDefinition[] {
+  const defs: CodexToolDefinition[] = [];
+  for (const toolGroup of tools) {
+    if (toolGroup.functionDeclarations) {
+      for (const fd of toolGroup.functionDeclarations) {
+        const def: CodexToolDefinition = {
+          type: "function",
+          name: fd.name,
+        };
+        if (fd.description) def.description = fd.description;
+        if (fd.parameters) def.parameters = fd.parameters;
+        defs.push(def);
+      }
+    }
+  }
+  return defs;
+}
+
+export function geminiToolConfigToCodex(
+  config: GeminiGenerateContentRequest["toolConfig"],
+): string | undefined {
+  if (!config?.functionCallingConfig?.mode) return undefined;
+  switch (config.functionCallingConfig.mode) {
+    case "AUTO":
+      return "auto";
+    case "NONE":
+      return "none";
+    case "ANY":
+      return "required";
+    default:
+      return undefined;
+  }
+}

src/types/codex-events.ts

@@ -43,6 +43,33 @@ export interface CodexCompletedEvent {
   response: CodexResponseData;
 }
 
+// ── Function call event data shapes ─────────────────────────────
+
+export interface CodexOutputItemAddedEvent {
+  type: "response.output_item.added";
+  outputIndex: number;
+  item: {
+    type: "function_call";
+    id: string;
+    call_id: string;
+    name: string;
+  };
+}
+
+export interface CodexFunctionCallArgsDeltaEvent {
+  type: "response.function_call_arguments.delta";
+  delta: string;
+  outputIndex: number;
+  call_id: string;
+}
+
+export interface CodexFunctionCallArgsDoneEvent {
+  type: "response.function_call_arguments.done";
+  arguments: string;
+  call_id: string;
+  name: string;
+}
+
 export interface CodexUnknownEvent {
   type: "unknown";
   raw: unknown;
@@ -54,6 +81,9 @@ export type TypedCodexEvent =
   | CodexTextDeltaEvent
   | CodexTextDoneEvent
   | CodexCompletedEvent
+  | CodexOutputItemAddedEvent
+  | CodexFunctionCallArgsDeltaEvent
+  | CodexFunctionCallArgsDoneEvent
   | CodexUnknownEvent;
 
 // ── Type guard / parser ──────────────────────────────────────────
@@ -115,6 +145,65 @@ export function parseCodexEvent(evt: CodexSSEEvent): TypedCodexEvent {
         ? { type: "response.completed", response: resp }
         : { type: "unknown", raw: data };
     }
+    case "response.output_item.added": {
+      if (
+        isRecord(data) &&
+        isRecord(data.item) &&
+        data.item.type === "function_call" &&
+        typeof data.item.call_id === "string" &&
+        typeof data.item.name === "string"
+      ) {
+        return {
+          type: "response.output_item.added",
+          outputIndex: typeof data.output_index === "number" ? data.output_index : 0,
+          item: {
+            type: "function_call",
+            id: typeof data.item.id === "string" ? data.item.id : "",
+            call_id: data.item.call_id,
+            name: data.item.name,
+          },
+        };
+      }
+      return { type: "unknown", raw: data };
+    }
+    case "response.function_call_arguments.delta": {
+      // Codex uses item_id (not call_id) on delta events
+      const deltaCallId = isRecord(data)
+        ? (typeof data.call_id === "string" ? data.call_id : typeof data.item_id === "string" ? data.item_id : "")
+        : "";
+      if (
+        isRecord(data) &&
+        typeof data.delta === "string" &&
+        deltaCallId
+      ) {
+        return {
+          type: "response.function_call_arguments.delta",
+          delta: data.delta,
+          outputIndex: typeof data.output_index === "number" ? data.output_index : 0,
+          call_id: deltaCallId,
+        };
+      }
+      return { type: "unknown", raw: data };
+    }
+    case "response.function_call_arguments.done": {
+      // Codex uses item_id (not call_id); name may be absent
+      const doneCallId = isRecord(data)
+        ? (typeof data.call_id === "string" ? data.call_id : typeof data.item_id === "string" ? data.item_id : "")
+        : "";
+      if (
+        isRecord(data) &&
+        typeof data.arguments === "string" &&
+        doneCallId
+      ) {
+        return {
+          type: "response.function_call_arguments.done",
+          arguments: data.arguments,
+          call_id: doneCallId,
+          name: typeof data.name === "string" ? data.name : "",
+        };
+      }
+      return { type: "unknown", raw: data };
+    }
     default:
       return { type: "unknown", raw: data };
   }

src/types/gemini.ts

@@ -64,9 +64,26 @@ export type GeminiContent = z.infer<typeof GeminiContentSchema>;
 
 // --- Response ---
 
+export interface GeminiFunctionCall {
+  name: string;
+  args?: Record<string, unknown>;
+}
+
+export interface GeminiFunctionResponse {
+  name: string;
+  response?: Record<string, unknown>;
+}
+
+export interface GeminiPart {
+  text?: string;
+  thought?: boolean;
+  functionCall?: GeminiFunctionCall;
+  functionResponse?: GeminiFunctionResponse;
+}
+
 export interface GeminiCandidate {
   content: {
-    parts: Array<{ text: string; thought?: boolean }>;
+    parts: GeminiPart[];
     role: "model";
   };
   finishReason?: "STOP" | "MAX_TOKENS" | "SAFETY" | "OTHER";

src/types/openai.ts

@@ -76,11 +76,21 @@ export type ChatCompletionRequest = z.infer<typeof ChatCompletionRequestSchema>;
 
 // --- Response (non-streaming) ---
 
+export interface ChatCompletionToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
 export interface ChatCompletionChoice {
   index: number;
   message: {
     role: "assistant";
     content: string | null;
+    tool_calls?: ChatCompletionToolCall[];
   };
   finish_reason: "stop" | "length" | "tool_calls" | "function_call" | null;
 }
@@ -102,9 +112,20 @@ export interface ChatCompletionResponse {
 
 // --- Response (streaming) ---
 
+export interface ChatCompletionChunkToolCall {
+  index: number;
+  id?: string;
+  type?: "function";
+  function?: {
+    name?: string;
+    arguments?: string;
+  };
+}
+
 export interface ChatCompletionChunkDelta {
   role?: "assistant";
   content?: string | null;
+  tool_calls?: ChatCompletionChunkToolCall[];
 }
 
 export interface ChatCompletionChunkChoice {