Merge pull request #6 from icebear0828/feat/tool-protocol-compat

src/routes/chat.ts

@@ -117,7 +117,9 @@ export function createChatRoutes(
           role: m.role,
           content: typeof m.content === "string"
             ? m.content
-            : m.content.filter((p) => p.type === "text" && p.text).map((p) => p.text!).join("\n"),
+            : m.content == null
+              ? ""
+              : m.content.filter((p) => p.type === "text" && p.text).map((p) => p.text!).join("\n"),
         })),
         model: codexRequest.model,
         isStreaming: req.stream,

src/translation/anthropic-to-codex.ts

@@ -23,15 +23,42 @@ function mapThinkingToEffort(
 
 /**
  * Extract text from Anthropic content (string or content block array).
+ * Flattens tool_use/tool_result blocks into readable text for Codex.
  */
 function flattenContent(
-  content: string | Array<{ type: string; text?: string }>,
+  content: string | Array<Record<string, unknown>>,
 ): string {
   if (typeof content === "string") return content;
-  return content
-    .filter((b) => b.type === "text" && b.text)
-    .map((b) => b.text!)
-    .join("\n");
+  const parts: string[] = [];
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    } else if (block.type === "tool_use") {
+      const name = typeof block.name === "string" ? block.name : "unknown";
+      let inputStr: string;
+      try {
+        inputStr = JSON.stringify(block.input, null, 2);
+      } catch {
+        inputStr = String(block.input);
+      }
+      parts.push(`[Tool Call: ${name}(${inputStr})]`);
+    } else if (block.type === "tool_result") {
+      const id =
+        typeof block.tool_use_id === "string" ? block.tool_use_id : "unknown";
+      let text = "";
+      if (typeof block.content === "string") {
+        text = block.content;
+      } else if (Array.isArray(block.content)) {
+        text = (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}`);
+    }
+  }
+  return parts.join("\n");
 }
 
 /**

src/translation/gemini-to-codex.ts

@@ -16,14 +16,40 @@ import { buildInstructions, budgetToEffort } from "./shared-utils.js";
 
 /**
  * Extract text from Gemini content parts.
+ * Flattens functionCall/functionResponse parts into readable text for Codex.
  */
 function flattenParts(
-  parts: Array<{ text?: string; thought?: boolean }>,
+  parts: Array<{
+    text?: string;
+    thought?: boolean;
+    functionCall?: { name: string; args?: Record<string, unknown> };
+    functionResponse?: { name: string; response?: Record<string, unknown> };
+  }>,
 ): string {
-  return parts
-    .filter((p) => p.text && !p.thought)
-    .map((p) => p.text!)
-    .join("\n");
+  const textParts: string[] = [];
+  for (const p of parts) {
+    if (p.thought) continue;
+    if (p.text) {
+      textParts.push(p.text);
+    } else if (p.functionCall) {
+      let args: string;
+      try {
+        args = JSON.stringify(p.functionCall.args ?? {}, null, 2);
+      } catch {
+        args = String(p.functionCall.args);
+      }
+      textParts.push(`[Tool Call: ${p.functionCall.name}(${args})]`);
+    } else if (p.functionResponse) {
+      let resp: string;
+      try {
+        resp = JSON.stringify(p.functionResponse.response ?? {}, null, 2);
+      } catch {
+        resp = String(p.functionResponse.response);
+      }
+      textParts.push(`[Tool Result (${p.functionResponse.name})]: ${resp}`);
+    }
+  }
+  return textParts.join("\n");
 }
 
 /**

src/translation/openai-to-codex.ts

@@ -11,8 +11,9 @@ import { resolveModelId, getModelInfo } from "../routes/models.js";
 import { getConfig } from "../config.js";
 import { buildInstructions } from "./shared-utils.js";
 
-/** Extract plain text from content (string or array of content parts). */
+/** Extract plain text from content (string, array, null, or undefined). */
 function extractText(content: ChatMessage["content"]): string {
+  if (content == null) return "";
   if (typeof content === "string") return content;
   return content
     .filter((p) => p.type === "text" && p.text)
@@ -20,6 +21,36 @@ 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.
  *
@@ -43,13 +74,33 @@ export function translateToCodexRequest(
   const instructions = buildInstructions(userInstructions);
 
   // Build input items from non-system messages
+  // Handles new format (tool/tool_calls) and legacy format (function/function_call)
   const input: CodexInputItem[] = [];
   for (const msg of req.messages) {
     if (msg.role === "system" || msg.role === "developer") continue;
-    input.push({
-      role: msg.role as "user" | "assistant",
-      content: extractText(msg.content),
-    });
+
+    if (msg.role === "assistant") {
+      const parts: string[] = [];
+      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") });
+    } else if (msg.role === "tool") {
+      const name = msg.name ?? msg.tool_call_id ?? "unknown";
+      input.push({
+        role: "user",
+        content: `[Tool Result (${name})]: ${extractText(msg.content)}`,
+      });
+    } else if (msg.role === "function") {
+      const name = msg.name ?? "unknown";
+      input.push({
+        role: "user",
+        content: `[Tool Result (${name})]: ${extractText(msg.content)}`,
+      });
+    } else {
+      input.push({ role: "user", content: extractText(msg.content) });
+    }
   }
 
   // Ensure at least one input message

src/types/anthropic.ts

@@ -19,9 +19,25 @@ const AnthropicImageContentSchema = z.object({
   }),
 });
 
+const AnthropicToolUseContentSchema = z.object({
+  type: z.literal("tool_use"),
+  id: z.string(),
+  name: z.string(),
+  input: z.record(z.unknown()),
+});
+
+const AnthropicToolResultContentSchema = z.object({
+  type: z.literal("tool_result"),
+  tool_use_id: z.string(),
+  content: z.union([z.string(), z.array(AnthropicTextContentSchema)]).optional(),
+  is_error: z.boolean().optional(),
+});
+
 const AnthropicContentBlockSchema = z.discriminatedUnion("type", [
   AnthropicTextContentSchema,
   AnthropicImageContentSchema,
+  AnthropicToolUseContentSchema,
+  AnthropicToolResultContentSchema,
 ]);
 
 const AnthropicContentSchema = z.union([
@@ -63,6 +79,17 @@ export const AnthropicMessagesRequestSchema = z.object({
   thinking: z
     .union([AnthropicThinkingEnabledSchema, AnthropicThinkingDisabledSchema])
     .optional(),
+  // Tool-related fields (accepted for compatibility, not forwarded to Codex)
+  tools: z.array(z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    input_schema: z.record(z.unknown()).optional(),
+  }).passthrough()).optional(),
+  tool_choice: z.union([
+    z.object({ type: z.literal("auto") }),
+    z.object({ type: z.literal("any") }),
+    z.object({ type: z.literal("tool"), name: z.string() }),
+  ]).optional(),
 });
 
 export type AnthropicMessagesRequest = z.infer<
@@ -72,9 +99,12 @@ export type AnthropicMessagesRequest = z.infer<
 // --- Response ---
 
 export interface AnthropicContentBlock {
-  type: "text" | "thinking";
+  type: "text" | "thinking" | "tool_use";
   text?: string;
   thinking?: string;
+  id?: string;
+  name?: string;
+  input?: Record<string, unknown>;
 }
 
 export interface AnthropicUsage {
@@ -88,7 +118,7 @@ export interface AnthropicMessagesResponse {
   role: "assistant";
   content: AnthropicContentBlock[];
   model: string;
-  stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | null;
+  stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
   stop_sequence: string | null;
   usage: AnthropicUsage;
 }

src/types/gemini.ts

@@ -8,6 +8,15 @@ import { z } from "zod";
 const GeminiPartSchema = z.object({
   text: z.string().optional(),
   thought: z.boolean().optional(),
+  // Function calling fields (accepted for compatibility, not forwarded to Codex)
+  functionCall: z.object({
+    name: z.string(),
+    args: z.record(z.unknown()).optional(),
+  }).optional(),
+  functionResponse: z.object({
+    name: z.string(),
+    response: z.record(z.unknown()).optional(),
+  }).optional(),
 });
 
 const GeminiContentSchema = z.object({
@@ -32,6 +41,20 @@ export const GeminiGenerateContentRequestSchema = z.object({
   contents: z.array(GeminiContentSchema).min(1),
   systemInstruction: GeminiContentSchema.optional(),
   generationConfig: GeminiGenerationConfigSchema.optional(),
+  // Tool-related fields (accepted for compatibility, not forwarded to Codex)
+  tools: z.array(z.object({
+    functionDeclarations: z.array(z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      parameters: z.record(z.unknown()).optional(),
+    })).optional(),
+  }).passthrough()).optional(),
+  toolConfig: z.object({
+    functionCallingConfig: z.object({
+      mode: z.enum(["AUTO", "NONE", "ANY"]).optional(),
+      allowedFunctionNames: z.array(z.string()).optional(),
+    }).optional(),
+  }).optional(),
 });
 
 export type GeminiGenerateContentRequest = z.infer<

src/types/openai.ts

@@ -11,9 +11,24 @@ const ContentPartSchema = z.object({
 }).passthrough();
 
 export const ChatMessageSchema = z.object({
-  role: z.enum(["system", "developer", "user", "assistant"]),
-  content: z.union([z.string(), z.array(ContentPartSchema)]),
+  role: z.enum(["system", "developer", "user", "assistant", "tool", "function"]),
+  content: z.union([z.string(), z.array(ContentPartSchema)]).nullable().optional(),
   name: z.string().optional(),
+  // New format: tool_calls (array, on assistant messages)
+  tool_calls: z.array(z.object({
+    id: z.string(),
+    type: z.literal("function"),
+    function: z.object({
+      name: z.string(),
+      arguments: z.string(),
+    }),
+  })).optional(),
+  tool_call_id: z.string().optional(),
+  // Legacy format: function_call (single object, on assistant messages)
+  function_call: z.object({
+    name: z.string(),
+    arguments: z.string(),
+  }).optional(),
 });
 
 export const ChatCompletionRequestSchema = z.object({
@@ -30,6 +45,30 @@ export const ChatCompletionRequestSchema = z.object({
   user: z.string().optional(),
   // Codex-specific extensions
   reasoning_effort: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+  // New tool format (accepted for compatibility, not forwarded to Codex)
+  tools: z.array(z.object({
+    type: z.literal("function"),
+    function: z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      parameters: z.record(z.unknown()).optional(),
+    }),
+  })).optional(),
+  tool_choice: z.union([
+    z.enum(["none", "auto", "required"]),
+    z.object({ type: z.literal("function"), function: z.object({ name: z.string() }) }),
+  ]).optional(),
+  parallel_tool_calls: z.boolean().optional(),
+  // Legacy function format (accepted for compatibility, not forwarded to Codex)
+  functions: z.array(z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.record(z.unknown()).optional(),
+  })).optional(),
+  function_call: z.union([
+    z.enum(["none", "auto"]),
+    z.object({ name: z.string() }),
+  ]).optional(),
 });
 
 export type ChatMessage = z.infer<typeof ChatMessageSchema>;
@@ -41,9 +80,9 @@ export interface ChatCompletionChoice {
   index: number;
   message: {
     role: "assistant";
-    content: string;
+    content: string | null;
   };
-  finish_reason: "stop" | "length" | null;
+  finish_reason: "stop" | "length" | "tool_calls" | "function_call" | null;
 }
 
 export interface ChatCompletionUsage {
@@ -65,13 +104,13 @@ export interface ChatCompletionResponse {
 
 export interface ChatCompletionChunkDelta {
   role?: "assistant";
-  content?: string;
+  content?: string | null;
 }
 
 export interface ChatCompletionChunkChoice {
   index: number;
   delta: ChatCompletionChunkDelta;
-  finish_reason: "stop" | "length" | null;
+  finish_reason: "stop" | "length" | "tool_calls" | "function_call" | null;
 }
 
 export interface ChatCompletionChunk {