@elvatis_com/openclaw-cli-bridge-elvatis 2.2.2 → 2.3.0

package/.ai/handoff/DASHBOARD.md

@@ -7,7 +7,7 @@ _Last updated: 2026-04-10_
 
 | Component | Version | Build | Tests | Status |
 |-----------|---------|-------|-------|--------|
-| openclaw-cli-bridge-elvatis | 2.2.2 | ✅ | ✅ | ✅ Stable |
+| openclaw-cli-bridge-elvatis | 2.3.0 | ✅ | ✅ | ✅ Stable |
 <!-- /SECTION: plugin_status -->
 
 <!-- SECTION: release_state -->
@@ -15,9 +15,9 @@ _Last updated: 2026-04-10_
 
 | Platform | Published Version | Status |
 |----------|------------------|--------|
-| GitHub | v2.2.2 | ✅ Pushed to main |
-| npm | 2.2.2 | ✅ Published (via CI) |
-| ClawHub | 2.2.2 | ✅ Published (via CI) |
+| GitHub | v2.3.0 | ✅ Pushed to main |
+| npm | 2.3.0 | ✅ Published (via CI) |
+| ClawHub | 2.3.0 | ✅ Published (via CI) |
 <!-- /SECTION: release_state -->
 
 <!-- SECTION: open_tasks -->
@@ -31,7 +31,8 @@ _No open tasks._
 
 | Task | Title | Version |
 |------|-------|---------|
-| T-018 | Fix vllm apiKey corruption (401) + harden config-patcher | 2.2.2 |
+| T-019 | Full-featured CLI bridge: tool calls + multimodal + autonomous execution | 2.3.0 |
+| T-018 | Fix vllm apiKey corruption (401) + harden config-patcher | 2.2.1 |
 | T-017 | Fix log spam, restart loops, CLI blocking | 2.2.0 |
 | T-016 | Issue #2: Codex auth auto-import into agent auth store | 2.1.0 |
 | T-015 | Issue #4: Background session mgmt with workdir isolation | 2.1.0 |

package/.ai/handoff/LOG.md

@@ -4,6 +4,25 @@ _Last 10 sessions. Older entries in LOG-ARCHIVE.md._
 
 ---
 
+## 2026-04-10 — Session 11 (Claude Opus 4.6)
+
+> **Agent:** claude-opus-4-6
+> **Phase:** feature
+> **Commit before:** v2.2.2
+> **Commit after:** v2.3.0
+
+**Full-featured CLI bridge: tool calls + multimodal + autonomous execution**
+
+- Added OpenAI tool calling protocol: tool definitions injected into prompts, structured `tool_calls` parsed from CLI output
+- Added multimodal content support: images/audio extracted to temp files, passed to CLIs via native mechanisms
+- Autonomous execution: Claude `--permission-mode bypassPermissions`, Gemini `--approval-mode yolo`
+- New `src/tool-protocol.ts` module (prompt builder, response parser, Claude wrapper extraction)
+- Removed HTTP 400 tool rejection — all CLI models now accept tool-calling requests
+- Model capabilities report `tools: true` for all CLI models
+- Reverted self-healing DEFAULT_MODEL_ORDER back to CLI models
+
+---
+
 ## 2026-04-10 — Session 10 (Claude Opus 4.6)
 
 > **Agent:** claude-opus-4-6

package/.ai/handoff/NEXT_ACTIONS.md

@@ -7,7 +7,7 @@ _Last updated: 2026-04-10_
 
 | Status  | Count |
 |---------|-------|
-| Done    | 18    |
+| Done    | 19    |
 | Ready   | 0     |
 | Blocked | 0     |
 <!-- /SECTION: summary -->
@@ -30,6 +30,7 @@ _No blocked tasks._
 
 | Task  | Title                                                              | Date       |
 |-------|--------------------------------------------------------------------|------------|
+| T-019 | Full CLI bridge: tool calls + multimodal + autonomous (v2.3.0)  | 2026-04-10 |
 | T-018 | Fix vllm apiKey corruption (401) + harden config-patcher (v2.2.1)| 2026-04-10 |
 | T-017 | Fix log spam, restart loops, CLI blocking (v2.2.0)               | 2026-04-09 |
 | T-016 | Issue #2: Codex auth auto-import into agent auth store            | 2026-03-19 |

package/.ai/handoff/STATUS.md

@@ -1,9 +1,9 @@
 # STATUS — openclaw-cli-bridge-elvatis
 
-## Current Version: 2.2.2
+## Current Version: 2.3.0
 
-- **npm:** @elvatis_com/openclaw-cli-bridge-elvatis@2.2.2
-- **ClawHub:** openclaw-cli-bridge-elvatis@2.2.2
+- **npm:** @elvatis_com/openclaw-cli-bridge-elvatis@2.3.0
+- **ClawHub:** openclaw-cli-bridge-elvatis@2.3.0
 - **GitHub:** https://github.com/elvatis/openclaw-cli-bridge-elvatis (pushed to main)
 
 ## CLI Model Token Limits (corrected in v1.9.2)
@@ -20,18 +20,18 @@
 ## Architecture
 - **Proxy server:** `http://127.0.0.1:31337/v1` (OpenAI-compatible)
 - **OpenClaw connects via** `vllm` provider with `api: openai-completions`
-- **CLI models** (`cli-claude/*`, `cli-gemini/*`): plain text completions only — NO tool/function call support
+- **CLI models** (`cli-claude/*`, `cli-gemini/*`, `openai-codex/*`): full tool calling + multimodal support via prompt injection + autonomous execution
 - **Web-session models** (`web-grok/*`, `web-gemini/*`): browser-based, require `/xxx-login`
 - **Codex models** (`openai-codex/*`): OAuth auth bridge
 - **BitNet** (`local-bitnet/*`): local CPU inference
 
-## Tool Support Limitation
-CLI models explicitly reject tool/function call requests (HTTP 400):
-```
-Model cli-claude/claude-opus-4-6 does not support tool/function calls.
-Use a native API model (e.g. github-copilot/gpt-5-mini) for agents that need tools.
-```
-This is by design — CLI tools output plain text only.
+## Tool Calling Support (v2.3.0)
+All CLI models now support the OpenAI tool calling protocol:
+- Tool definitions are injected into the prompt as structured instructions
+- CLI output is parsed for structured `tool_calls` JSON responses
+- Responses are returned in standard OpenAI `tool_calls` format with `finish_reason: "tool_calls"`
+- Multimodal content (images, audio) is extracted to temp files and passed to CLIs
+- All models run in autonomous mode: Claude `bypassPermissions`, Gemini `yolo`, Codex `full-auto`
 
 ## All 4 Browser Providers
 | Provider | Models | Login Cmd | Profile Dir |
@@ -47,6 +47,7 @@ This is by design — CLI tools output plain text only.
 - /bridge-status shows cookie-based status
 
 ## Release History (recent)
+- v2.3.0 (2026-04-10): Tool calling protocol, multimodal content, autonomous execution mode
 - v2.2.1 (2026-04-10): Fix vllm apiKey corruption (401 Unauthorized) + harden config-patcher to re-patch on wrong apiKey
 - v2.2.0 (2026-04-09): Fix log spam (module-level guards), remove fuser -k restart loops, session restore gateway-only, EADDRINUSE graceful handling
 - v2.1.0 (2026-03-19): Issue #6 workdir isolation, Issue #4 session mgmt enhancements, Issue #2 codex auth auto-import

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code, OpenCode, Pi) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `2.2.2`
+**Current version:** `2.3.0`
 
 ---
 
@@ -376,6 +376,14 @@ npm run ci          # lint + typecheck + test
 
 ## Changelog
 
+### v2.3.0
+- **feat:** OpenAI tool calling protocol support for all CLI models — tool definitions are injected into the prompt, structured `tool_calls` responses are parsed and returned in OpenAI format
+- **feat:** Multimodal content support — images and audio from webchat are extracted to temp files and passed to CLIs (Codex uses native `-i` flag, Claude/Gemini reference file paths in prompt)
+- **feat:** Autonomous execution mode — Claude uses `--permission-mode bypassPermissions`, Gemini uses `--approval-mode yolo`, Codex uses `--full-auto`. CLI models never ask interactive questions.
+- **feat:** New `src/tool-protocol.ts` module — tool prompt builder, response parser, call ID generator
+- **fix:** Removed `--tools ""` from Claude CLI args — allows native tool execution when needed
+- **fix:** Model capabilities now report `tools: true` for all CLI models (was `false`)
+
 ### v2.2.1
 - **fix:** Config-patcher now validates `apiKey` value — re-patches if `__OPENCLAW_KEEP__` or any wrong value is present (prevents vllm 401 Unauthorized after config migrations)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/cli-runner.ts

@@ -18,9 +18,16 @@
 
 import { spawn, execSync } from "node:child_process";
 import { tmpdir, homedir } from "node:os";
-import { existsSync } from "node:fs";
+import { existsSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { randomBytes } from "node:crypto";
 import { ensureClaudeToken, refreshClaudeToken } from "./claude-auth.js";
+import {
+  type ToolDefinition,
+  type CliToolResult,
+  buildToolPromptBlock,
+  parseToolCallResponse,
+} from "./tool-protocol.js";
 
 /** Max messages to include in the prompt sent to the CLI. */
 const MAX_MESSAGES = 20;
@@ -37,15 +44,28 @@ export interface ContentPart {
 }
 
 export interface ChatMessage {
-  role: "system" | "user" | "assistant";
+  role: "system" | "user" | "assistant" | "tool";
   /** Plain string or OpenAI-style content array (multimodal / structured). */
   content: string | ContentPart[] | unknown;
+  /** Tool calls made by the assistant (OpenAI tool calling protocol). */
+  tool_calls?: Array<{ id: string; type: string; function: { name: string; arguments: string } }>;
+  /** ID linking a tool result to the assistant's tool_call. */
+  tool_call_id?: string;
+  /** Function name for tool result messages. */
+  name?: string;
 }
 
+// Re-export tool-protocol types for convenience
+export type { ToolDefinition, CliToolResult } from "./tool-protocol.js";
+
 /**
  * Convert OpenAI messages to a single flat prompt string.
  * Truncates to MAX_MESSAGES (keeping the most recent) and MAX_MSG_CHARS per
  * message to avoid oversized payloads.
+ *
+ * Handles tool-calling messages:
+ *   - role "tool": formatted as [Tool Result: name]
+ *   - role "assistant" with tool_calls: formatted as [Assistant Tool Call: name(args)]
  */
 export function formatPrompt(messages: ChatMessage[]): string {
   if (messages.length === 0) return "";
@@ -63,6 +83,22 @@ export function formatPrompt(messages: ChatMessage[]): string {
 
   return truncated
     .map((m) => {
+      // Assistant message with tool_calls (no text content)
+      if (m.role === "assistant" && m.tool_calls?.length) {
+        const calls = m.tool_calls.map((tc) =>
+          `[Assistant Tool Call: ${tc.function.name}(${tc.function.arguments})]\n`
+        ).join("");
+        const content = m.content ? truncateContent(m.content) : "";
+        return content ? `${calls}\n${content}` : calls.trimEnd();
+      }
+
+      // Tool result message
+      if (m.role === "tool") {
+        const name = m.name ?? "unknown";
+        const content = truncateContent(m.content);
+        return `[Tool Result: ${name}]\n${content}`;
+      }
+
       const content = truncateContent(m.content);
       switch (m.role) {
         case "system":    return `[System]\n${content}`;
@@ -79,7 +115,7 @@ export function formatPrompt(messages: ChatMessage[]): string {
  *
  * Handles:
  *  - string          → as-is
- *  - ContentPart[]   → join text parts (OpenAI multimodal format)
+ *  - ContentPart[]   → join text parts + describe non-text parts (multimodal)
  *  - other object    → JSON.stringify (prevents "[object Object]" from reaching the CLI)
  *  - null/undefined  → ""
  */
@@ -87,9 +123,14 @@ function contentToString(content: unknown): string {
   if (typeof content === "string") return content;
   if (content === null || content === undefined) return "";
   if (Array.isArray(content)) {
-    return (content as ContentPart[])
-      .filter((c) => c?.type === "text" && typeof c.text === "string")
-      .map((c) => c.text!)
+    return (content as Record<string, unknown>[])
+      .map((c) => {
+        if (c?.type === "text" && typeof c.text === "string") return c.text;
+        if (c?.type === "image_url") return "[Attached image — see saved media file]";
+        if (c?.type === "input_audio") return "[Attached audio — see saved media file]";
+        return null;
+      })
+      .filter(Boolean)
       .join("\n");
   }
   if (typeof content === "object") return JSON.stringify(content);
@@ -102,6 +143,92 @@ function truncateContent(raw: unknown): string {
   return s.slice(0, MAX_MSG_CHARS) + `\n...[truncated ${s.length - MAX_MSG_CHARS} chars]`;
 }
 
+// ──────────────────────────────────────────────────────────────────────────────
+// Multimodal content extraction
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface MediaFile {
+  path: string;
+  mimeType: string;
+}
+
+const MEDIA_TMP_DIR = join(tmpdir(), "cli-bridge-media");
+
+/**
+ * Extract non-text content parts (images, audio) from messages.
+ * Saves base64 data to temp files and replaces media parts with file references.
+ * Returns cleaned messages + list of saved media files for CLI -i flags.
+ */
+export function extractMultimodalParts(messages: ChatMessage[]): {
+  cleanMessages: ChatMessage[];
+  mediaFiles: MediaFile[];
+} {
+  const mediaFiles: MediaFile[] = [];
+  const cleanMessages = messages.map((m) => {
+    if (!Array.isArray(m.content)) return m;
+
+    const parts = m.content as Record<string, unknown>[];
+    const newParts: Record<string, unknown>[] = [];
+
+    for (const part of parts) {
+      if (part?.type === "image_url") {
+        const imageUrl = (part as { image_url?: { url?: string } }).image_url;
+        const url = imageUrl?.url ?? "";
+        if (url.startsWith("data:")) {
+          // data:image/png;base64,iVBOR...
+          const match = url.match(/^data:(image\/\w+);base64,(.+)$/);
+          if (match) {
+            const ext = match[1].split("/")[1] || "png";
+            const filePath = saveBase64ToTemp(match[2], ext);
+            mediaFiles.push({ path: filePath, mimeType: match[1] });
+            newParts.push({ type: "text", text: `[Attached image: ${filePath}]` });
+            continue;
+          }
+        }
+        // URL-based image — include URL reference in text
+        newParts.push({ type: "text", text: `[Image URL: ${url}]` });
+        continue;
+      }
+
+      if (part?.type === "input_audio") {
+        const audioData = (part as { input_audio?: { data?: string; format?: string } }).input_audio;
+        if (audioData?.data) {
+          const ext = audioData.format || "wav";
+          const filePath = saveBase64ToTemp(audioData.data, ext);
+          mediaFiles.push({ path: filePath, mimeType: `audio/${ext}` });
+          newParts.push({ type: "text", text: `[Attached audio: ${filePath}]` });
+          continue;
+        }
+      }
+
+      // Keep text parts and anything else as-is
+      newParts.push(part);
+    }
+
+    return { ...m, content: newParts };
+  });
+
+  return { cleanMessages, mediaFiles };
+}
+
+function saveBase64ToTemp(base64Data: string, ext: string): string {
+  mkdirSync(MEDIA_TMP_DIR, { recursive: true });
+  const fileName = `media-${randomBytes(8).toString("hex")}.${ext}`;
+  const filePath = join(MEDIA_TMP_DIR, fileName);
+  writeFileSync(filePath, Buffer.from(base64Data, "base64"));
+  return filePath;
+}
+
+/** Schedule deletion of temp media files after a delay. */
+export function cleanupMediaFiles(files: MediaFile[], delayMs = 60_000): void {
+  if (files.length === 0) return;
+  setTimeout(() => {
+    for (const f of files) {
+      try { unlinkSync(f.path); } catch { /* already deleted */ }
+    }
+  }, delayMs);
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Minimal environment for spawned subprocesses
 // ──────────────────────────────────────────────────────────────────────────────
@@ -263,13 +390,21 @@ export async function runGemini(
   prompt: string,
   modelId: string,
   timeoutMs: number,
-  workdir?: string
+  workdir?: string,
+  opts?: { tools?: ToolDefinition[] }
 ): Promise<string> {
   const model = stripPrefix(modelId);
   // -p "" = headless mode trigger; actual prompt arrives via stdin
-  const args = ["-m", model, "-p", ""];
+  // --approval-mode yolo: auto-approve all tool executions, never ask questions
+  const args = ["-m", model, "-p", "", "--approval-mode", "yolo"];
   const cwd = workdir ?? tmpdir();
-  const result = await runCli("gemini", args, prompt, timeoutMs, { cwd });
+
+  // When tools are present, prepend tool instructions to prompt
+  const effectivePrompt = opts?.tools?.length
+    ? buildToolPromptBlock(opts.tools) + "\n\n" + prompt
+    : prompt;
+
+  const result = await runCli("gemini", args, effectivePrompt, timeoutMs, { cwd });
 
   // Filter out [WARN] lines from stderr (Gemini emits noisy permission warnings)
   const cleanStderr = result.stderr
@@ -298,23 +433,31 @@ export async function runClaude(
   prompt: string,
   modelId: string,
   timeoutMs: number,
-  workdir?: string
+  workdir?: string,
+  opts?: { tools?: ToolDefinition[] }
 ): Promise<string> {
   // Proactively refresh OAuth token if it's about to expire (< 5 min remaining).
   // No-op for API-key users.
   await ensureClaudeToken();
 
   const model = stripPrefix(modelId);
-  const args = [
+  // Always use bypassPermissions to ensure fully autonomous execution (never asks questions).
+  // Use text output for all cases — JSON schema is unreliable with Claude Code's system prompt.
+  const args: string[] = [
     "-p",
     "--output-format", "text",
-    "--permission-mode", "plan",
-    "--tools", "",
+    "--permission-mode", "bypassPermissions",
+    "--dangerously-skip-permissions",
     "--model", model,
   ];
 
+  // When tools are present, prepend tool instructions to prompt
+  const effectivePrompt = opts?.tools?.length
+    ? buildToolPromptBlock(opts.tools) + "\n\n" + prompt
+    : prompt;
+
   const cwd = workdir ?? homedir();
-  const result = await runCli("claude", args, prompt, timeoutMs, { cwd });
+  const result = await runCli("claude", args, effectivePrompt, timeoutMs, { cwd });
 
   // On 401: attempt one token refresh + retry before giving up.
   if (result.exitCode !== 0 && result.stdout.length === 0) {
@@ -322,7 +465,7 @@ export async function runClaude(
     if (stderr.includes("401") || stderr.includes("Invalid authentication credentials") || stderr.includes("authentication_error")) {
       // Refresh and retry once
       await refreshClaudeToken();
-      const retry = await runCli("claude", args, prompt, timeoutMs, { cwd });
+      const retry = await runCli("claude", args, effectivePrompt, timeoutMs, { cwd });
       if (retry.exitCode !== 0 && retry.stdout.length === 0) {
         const retryStderr = retry.stderr || "(no output)";
         if (retryStderr.includes("401") || retryStderr.includes("authentication_error") || retryStderr.includes("Invalid authentication credentials")) {
@@ -364,16 +507,32 @@ export async function runCodex(
   prompt: string,
   modelId: string,
   timeoutMs: number,
-  workdir?: string
+  workdir?: string,
+  opts?: { tools?: ToolDefinition[]; mediaFiles?: MediaFile[] }
 ): Promise<string> {
   const model = stripPrefix(modelId);
   const args = ["--model", model, "--quiet", "--full-auto"];
+
+  // Codex supports native image input via -i flag
+  if (opts?.mediaFiles?.length) {
+    for (const f of opts.mediaFiles) {
+      if (f.mimeType.startsWith("image/")) {
+        args.push("-i", f.path);
+      }
+    }
+  }
+
   const cwd = workdir ?? homedir();
 
   // Codex requires a git repo in the working directory
   ensureGitRepo(cwd);
 
-  const result = await runCli("codex", args, prompt, timeoutMs, { cwd });
+  // When tools are present, prepend tool instructions to prompt
+  const effectivePrompt = opts?.tools?.length
+    ? buildToolPromptBlock(opts.tools) + "\n\n" + prompt
+    : prompt;
+
+  const result = await runCli("codex", args, effectivePrompt, timeoutMs, { cwd });
 
   if (result.exitCode !== 0 && result.stdout.length === 0) {
     throw new Error(`codex exited ${result.exitCode}: ${result.stderr || "(no output)"}`);
@@ -494,6 +653,16 @@ export interface RouteOptions {
    * Overrides the per-runner default (tmpdir for gemini, homedir for others).
    */
   workdir?: string;
+  /**
+   * OpenAI tool definitions. When present, tool instructions are injected
+   * into the prompt and structured tool_call responses are parsed.
+   */
+  tools?: ToolDefinition[];
+  /**
+   * Media files extracted from multimodal message content.
+   * Passed to CLIs that support native media input (e.g. codex -i).
+   */
+  mediaFiles?: MediaFile[];
 }
 
 /**
@@ -504,6 +673,9 @@ export interface RouteOptions {
  *   opencode/<id>        → opencode CLI
  *   pi/<id>              → pi CLI
  *
+ * When `tools` are provided, tool instructions are injected into the prompt
+ * and the response is parsed for structured tool_calls.
+ *
  * Enforces DEFAULT_ALLOWED_CLI_MODELS by default (T-103).
  * Pass `allowedModels: null` to skip the allowlist check.
  */
@@ -512,8 +684,9 @@ export async function routeToCliRunner(
   messages: ChatMessage[],
   timeoutMs: number,
   opts: RouteOptions = {}
-): Promise<string> {
+): Promise<CliToolResult> {
   const prompt = formatPrompt(messages);
+  const hasTools = !!(opts.tools?.length);
 
   // Strip "vllm/" prefix if present — OpenClaw sends the full provider path
   // (e.g. "vllm/cli-claude/claude-sonnet-4-6") but the router only needs the
@@ -535,15 +708,23 @@ export async function routeToCliRunner(
   // Resolve aliases (e.g. gemini-3-pro → gemini-3-pro-preview) after allowlist check
   const resolved = normalizeModelAlias(normalized);
 
-  if (resolved.startsWith("cli-gemini/"))   return runGemini(prompt, resolved, timeoutMs, opts.workdir);
-  if (resolved.startsWith("cli-claude/"))   return runClaude(prompt, resolved, timeoutMs, opts.workdir);
-  if (resolved.startsWith("openai-codex/")) return runCodex(prompt, resolved, timeoutMs, opts.workdir);
-  if (resolved.startsWith("opencode/"))     return runOpenCode(prompt, resolved, timeoutMs, opts.workdir);
-  if (resolved.startsWith("pi/"))           return runPi(prompt, resolved, timeoutMs, opts.workdir);
-
-  throw new Error(
+  let rawText: string;
+  if (resolved.startsWith("cli-gemini/"))        rawText = await runGemini(prompt, resolved, timeoutMs, opts.workdir, { tools: opts.tools });
+  else if (resolved.startsWith("cli-claude/"))   rawText = await runClaude(prompt, resolved, timeoutMs, opts.workdir, { tools: opts.tools });
+  else if (resolved.startsWith("openai-codex/")) rawText = await runCodex(prompt, resolved, timeoutMs, opts.workdir, { tools: opts.tools, mediaFiles: opts.mediaFiles });
+  else if (resolved.startsWith("opencode/"))     rawText = await runOpenCode(prompt, resolved, timeoutMs, opts.workdir);
+  else if (resolved.startsWith("pi/"))           rawText = await runPi(prompt, resolved, timeoutMs, opts.workdir);
+  else throw new Error(
     `Unknown CLI bridge model: "${model}". Use "vllm/cli-gemini/<model>", "vllm/cli-claude/<model>", "openai-codex/<model>", "opencode/<model>", or "pi/<model>".`
   );
+
+  // When tools were provided, try to parse structured tool_calls from the response
+  if (hasTools) {
+    return parseToolCallResponse(rawText);
+  }
+
+  // No tools — wrap plain text
+  return { content: rawText };
 }
 
 // ──────────────────────────────────────────────────────────────────────────────

package/src/proxy-server.ts

@@ -10,7 +10,7 @@
 
 import http from "node:http";
 import { randomBytes } from "node:crypto";
-import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
+import { type ChatMessage, type CliToolResult, type ToolDefinition, routeToCliRunner, extractMultimodalParts, cleanupMediaFiles } from "./cli-runner.js";
 import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
 import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
 import { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
@@ -258,9 +258,8 @@ async function handleRequest(
           object: "model",
           created: now,
           owned_by: "openclaw-cli-bridge",
-          // CLI-proxy models stream plain text — no tool/function call support
           capabilities: {
-            tools: !(m.id.startsWith("cli-gemini/") || m.id.startsWith("cli-claude/") || m.id.startsWith("openai-codex/") || m.id.startsWith("opencode/") || m.id.startsWith("pi/") || m.id.startsWith("local-bitnet/")),
+            tools: !m.id.startsWith("local-bitnet/"), // all CLI models support tools via prompt injection; only bitnet is text-only
           },
         })),
       })
@@ -296,9 +295,10 @@ async function handleRequest(
       return;
     }
 
-    const { model, messages, stream = false } = parsed as { model: string; messages: ChatMessage[]; stream?: boolean; tools?: unknown; workdir?: string };
+    const { model, messages, stream = false } = parsed as { model: string; messages: ChatMessage[]; stream?: boolean; tools?: ToolDefinition[]; workdir?: string };
     const workdir = (parsed as { workdir?: string }).workdir;
-    const hasTools = Array.isArray((parsed as { tools?: unknown }).tools) && (parsed as { tools?: unknown[] }).tools!.length > 0;
+    const tools = (parsed as { tools?: ToolDefinition[] }).tools;
+    const hasTools = Array.isArray(tools) && tools.length > 0;
 
     if (!model || !messages?.length) {
       res.writeHead(400, { "Content-Type": "application/json" });
@@ -306,23 +306,10 @@ async function handleRequest(
       return;
     }
 
-    // CLI-proxy models (cli-gemini/*, cli-claude/*) are plain text completions —
-    // they cannot process tool/function call schemas. Return a clear 400 so
-    // OpenClaw can surface a meaningful error instead of getting a garbled response.
-    const isCliModel = model.startsWith("cli-gemini/") || model.startsWith("cli-claude/") || model.startsWith("openai-codex/") || model.startsWith("opencode/") || model.startsWith("pi/"); // local-bitnet/* exempt: llama-server silently ignores tools
-    if (hasTools && isCliModel) {
-      res.writeHead(400, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({
-        error: {
-          message: `Model ${model} does not support tool/function calls. Use a native API model (e.g. github-copilot/gpt-5-mini) for agents that need tools.`,
-          type: "invalid_request_error",
-          code: "tools_not_supported",
-        }
-      }));
-      return;
-    }
+    // Extract multimodal content (images, audio) from messages → temp files
+    const { cleanMessages, mediaFiles } = extractMultimodalParts(messages);
 
-    opts.log(`[cli-bridge] ${model} · ${messages.length} msg(s) · stream=${stream}${hasTools ? " · tools=unsupported→rejected" : ""}`);
+    opts.log(`[cli-bridge] ${model} · ${cleanMessages.length} msg(s) · stream=${stream}${hasTools ? ` · tools=${tools!.length}` : ""}${mediaFiles.length ? ` · media=${mediaFiles.length}` : ""}`);
 
     const id = `chatcmpl-cli-${randomBytes(6).toString("hex")}`;
     const created = Math.floor(Date.now() / 1000);
@@ -612,11 +599,12 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
-    // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
-    let content: string;
+    // ── CLI runner routing (Gemini / Claude Code / Codex) ──────────────────────
+    let result: CliToolResult;
     let usedModel = model;
+    const routeOpts = { workdir, tools: hasTools ? tools : undefined, mediaFiles: mediaFiles.length ? mediaFiles : undefined };
     try {
-      content = await routeToCliRunner(model, messages, opts.timeoutMs ?? 120_000, { workdir });
+      result = await routeToCliRunner(model, cleanMessages, opts.timeoutMs ?? 120_000, routeOpts);
     } catch (err) {
       const msg = (err as Error).message;
       // ── Model fallback: retry once with a lighter model if configured ────
@@ -624,7 +612,7 @@ async function handleRequest(
       if (fallbackModel) {
         opts.warn(`[cli-bridge] ${model} failed (${msg}), falling back to ${fallbackModel}`);
         try {
-          content = await routeToCliRunner(fallbackModel, messages, opts.timeoutMs ?? 120_000, { workdir });
+          result = await routeToCliRunner(fallbackModel, cleanMessages, opts.timeoutMs ?? 120_000, routeOpts);
           usedModel = fallbackModel;
           opts.log(`[cli-bridge] fallback to ${fallbackModel} succeeded`);
         } catch (fallbackErr) {
@@ -640,8 +628,14 @@ async function handleRequest(
         res.end(JSON.stringify({ error: { message: msg, type: "cli_error" } }));
         return;
       }
+    } finally {
+      // Clean up temp media files after response
+      cleanupMediaFiles(mediaFiles);
     }
 
+    const hasToolCalls = !!(result.tool_calls?.length);
+    const finishReason = hasToolCalls ? "tool_calls" : "stop";
+
     if (stream) {
       res.writeHead(200, {
         "Content-Type": "text/event-stream",
@@ -650,26 +644,59 @@ async function handleRequest(
         ...corsHeaders(),
       });
 
-      // Role chunk
-      sendSseChunk(res, { id, created, model: usedModel, delta: { role: "assistant" }, finish_reason: null });
-
-      // Content in chunks (~50 chars each for natural feel)
-      const chunkSize = 50;
-      for (let i = 0; i < content.length; i += chunkSize) {
+      if (hasToolCalls) {
+        // Stream tool_calls in OpenAI SSE format
+        const toolCalls = result.tool_calls!;
+        // Role chunk with all tool_calls (name + empty arguments)
         sendSseChunk(res, {
-          id,
-          created,
-          model: usedModel,
-          delta: { content: content.slice(i, i + chunkSize) },
+          id, created, model: usedModel,
+          delta: {
+            role: "assistant",
+            tool_calls: toolCalls.map((tc, idx) => ({
+              index: idx, id: tc.id, type: "function",
+              function: { name: tc.function.name, arguments: "" },
+            })),
+          },
           finish_reason: null,
         });
+        // Arguments chunks (one per tool call)
+        for (let idx = 0; idx < toolCalls.length; idx++) {
+          sendSseChunk(res, {
+            id, created, model: usedModel,
+            delta: {
+              tool_calls: [{ index: idx, function: { arguments: toolCalls[idx].function.arguments } }],
+            },
+            finish_reason: null,
+          });
+        }
+        // Stop chunk
+        sendSseChunk(res, { id, created, model: usedModel, delta: {}, finish_reason: "tool_calls" });
+      } else {
+        // Standard text streaming
+        sendSseChunk(res, { id, created, model: usedModel, delta: { role: "assistant" }, finish_reason: null });
+        const content = result.content ?? "";
+        const chunkSize = 50;
+        for (let i = 0; i < content.length; i += chunkSize) {
+          sendSseChunk(res, {
+            id, created, model: usedModel,
+            delta: { content: content.slice(i, i + chunkSize) },
+            finish_reason: null,
+          });
+        }
+        sendSseChunk(res, { id, created, model: usedModel, delta: {}, finish_reason: "stop" });
       }
 
-      // Stop chunk
-      sendSseChunk(res, { id, created, model: usedModel, delta: {}, finish_reason: "stop" });
       res.write("data: [DONE]\n\n");
       res.end();
     } else {
+      const message: Record<string, unknown> = { role: "assistant" };
+      if (hasToolCalls) {
+        message.content = null;
+        message.tool_calls = result.tool_calls;
+      } else {
+        message.content = result.content;
+      }
+
       const response = {
         id,
         object: "chat.completion",
@@ -678,8 +705,8 @@ async function handleRequest(
         choices: [
           {
             index: 0,
-            message: { role: "assistant", content },
-            finish_reason: "stop",
+            message,
+            finish_reason: finishReason,
           },
         ],
         usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },

package/src/tool-protocol.ts

@@ -0,0 +1,269 @@
+/**
+ * tool-protocol.ts
+ *
+ * Translates between the OpenAI tool-calling protocol and CLI text I/O.
+ *
+ * - buildToolPromptBlock(): injects tool definitions + instructions into the prompt
+ * - buildToolCallJsonSchema(): returns JSON schema for Claude's --json-schema flag
+ * - parseToolCallResponse(): extracts tool_calls from CLI output text/JSON
+ * - generateCallId(): unique call IDs for tool_calls
+ */
+
+import { randomBytes } from "node:crypto";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Types
+// ──────────────────────────────────────────────────────────────────────────────
+
+export interface ToolDefinition {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export interface ToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string; // JSON-encoded arguments
+  };
+}
+
+export interface CliToolResult {
+  content: string | null;
+  tool_calls?: ToolCall[];
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Prompt building
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Build a text block describing available tools and response format instructions.
+ * This block is prepended to the system message (or added as a new system message).
+ */
+export function buildToolPromptBlock(tools: ToolDefinition[]): string {
+  const toolDescriptions = tools
+    .map((t) => {
+      const fn = t.function;
+      const params = JSON.stringify(fn.parameters);
+      return `- name: ${fn.name}\n  description: ${fn.description}\n  parameters: ${params}`;
+    })
+    .join("\n");
+
+  return [
+    "You have access to the following tools.",
+    "",
+    "IMPORTANT: You must respond with ONLY valid JSON in one of these two formats:",
+    "",
+    'To call one or more tools, respond with ONLY:',
+    '{"tool_calls":[{"name":"<tool_name>","arguments":{<parameters as JSON object>}}]}',
+    "",
+    'To respond with text (no tool call needed), respond with ONLY:',
+    '{"content":"<your text response>"}',
+    "",
+    "Do NOT include any text outside the JSON. Do NOT wrap in markdown code blocks.",
+    "",
+    "Available tools:",
+    toolDescriptions,
+  ].join("\n");
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// JSON Schema for Claude's --json-schema flag
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Returns a JSON schema that constrains Claude's output to either:
+ * - { "content": "text response" }
+ * - { "tool_calls": [{ "name": "...", "arguments": { ... } }] }
+ */
+export function buildToolCallJsonSchema(): object {
+  return {
+    type: "object",
+    properties: {
+      content: { type: "string" },
+      tool_calls: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            arguments: { type: "object" },
+          },
+          required: ["name", "arguments"],
+        },
+      },
+    },
+    additionalProperties: false,
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Response parsing
+// ──────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Parse CLI output text into a CliToolResult.
+ *
+ * Tries to extract JSON from the text. If valid JSON with tool_calls is found,
+ * returns structured tool calls. Otherwise returns the text as content.
+ *
+ * Never throws — always returns a valid result.
+ */
+export function parseToolCallResponse(text: string): CliToolResult {
+  const trimmed = text.trim();
+
+  // Check for Claude's --output-format json wrapper FIRST.
+  // Claude returns: { "type": "result", "result": "..." }
+  // The inner `result` field contains the actual model output (with tool_calls or content).
+  const claudeResult = tryExtractClaudeJsonResult(trimmed);
+  if (claudeResult) {
+    const inner = tryParseJson(claudeResult);
+    if (inner) return normalizeResult(inner);
+    // Claude result is plain text
+    return { content: claudeResult };
+  }
+
+  // Try direct JSON parse (for non-Claude outputs)
+  const parsed = tryParseJson(trimmed);
+  if (parsed) return normalizeResult(parsed);
+
+  // Try extracting JSON from markdown code blocks: ```json ... ```
+  const codeBlock = tryExtractCodeBlock(trimmed);
+  if (codeBlock) {
+    const inner = tryParseJson(codeBlock);
+    if (inner) return normalizeResult(inner);
+  }
+
+  // Try finding a JSON object anywhere in the text
+  const embedded = tryExtractEmbeddedJson(trimmed);
+  if (embedded) {
+    const inner = tryParseJson(embedded);
+    if (inner) return normalizeResult(inner);
+  }
+
+  // Fallback: treat entire text as content
+  return { content: trimmed || null };
+}
+
+/**
+ * Normalize a parsed JSON object into a CliToolResult.
+ */
+function normalizeResult(obj: Record<string, unknown>): CliToolResult {
+  // Check for tool_calls array
+  if (Array.isArray(obj.tool_calls) && obj.tool_calls.length > 0) {
+    const toolCalls: ToolCall[] = obj.tool_calls.map((tc: Record<string, unknown>) => ({
+      id: generateCallId(),
+      type: "function" as const,
+      function: {
+        name: String(tc.name ?? ""),
+        arguments: typeof tc.arguments === "string"
+          ? tc.arguments
+          : JSON.stringify(tc.arguments ?? {}),
+      },
+    }));
+    return { content: null, tool_calls: toolCalls };
+  }
+
+  // Check for content field
+  if (typeof obj.content === "string") {
+    return { content: obj.content };
+  }
+
+  // Unknown structure — serialize as content
+  return { content: JSON.stringify(obj) };
+}
+
+function tryParseJson(text: string): Record<string, unknown> | null {
+  try {
+    const obj = JSON.parse(text);
+    if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+      return obj as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the model output from Claude's JSON output wrapper.
+ * Claude CLI with --output-format json returns:
+ * { "type": "result", "result": "the model output",
+ *   "structured_output": { "content": "..." }, ... }
+ *
+ * When --json-schema is used, the `result` field is the JSON-schema-constrained output.
+ * The `structured_output.content` field may also contain the raw output.
+ */
+function tryExtractClaudeJsonResult(text: string): string | null {
+  try {
+    const obj = JSON.parse(text);
+    if (obj?.type === "result") {
+      // Prefer structured_output.content if available
+      if (typeof obj.structured_output?.content === "string") {
+        return obj.structured_output.content;
+      }
+      if (typeof obj.result === "string") {
+        return obj.result;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Extract JSON from ```json ... ``` or ``` ... ``` code blocks. */
+function tryExtractCodeBlock(text: string): string | null {
+  const match = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  return match?.[1]?.trim() ?? null;
+}
+
+/** Find the first { ... } JSON object in text (greedy, balanced braces). */
+function tryExtractEmbeddedJson(text: string): string | null {
+  const start = text.indexOf("{");
+  if (start === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") depth++;
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return text.slice(start, i + 1);
+      }
+    }
+  }
+  return null;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Utilities
+// ──────────────────────────────────────────────────────────────────────────────
+
+/** Generate a unique tool call ID: "call_" + 12 random hex characters. */
+export function generateCallId(): string {
+  return "call_" + randomBytes(6).toString("hex");
+}

package/test/cli-runner-extended.test.ts

@@ -189,7 +189,7 @@ describe("routeToCliRunner — new model prefixes", () => {
       [{ role: "user", content: "hi" }],
       5000
     );
-    expect(result).toBe("routed output");
+    expect(result).toEqual({ content: "routed output" });
     expect(mockSpawn).toHaveBeenCalledWith("codex", expect.any(Array), expect.any(Object));
   });
 
@@ -200,7 +200,7 @@ describe("routeToCliRunner — new model prefixes", () => {
       5000,
       { allowedModels: null }
     );
-    expect(result).toBe("routed output");
+    expect(result).toEqual({ content: "routed output" });
     expect(mockSpawn).toHaveBeenCalledWith("codex", expect.any(Array), expect.any(Object));
   });
 
@@ -210,7 +210,7 @@ describe("routeToCliRunner — new model prefixes", () => {
       [{ role: "user", content: "hi" }],
       5000
     );
-    expect(result).toBe("routed output");
+    expect(result).toEqual({ content: "routed output" });
     expect(mockSpawn).toHaveBeenCalledWith("opencode", expect.any(Array), expect.any(Object));
   });
 
@@ -220,7 +220,7 @@ describe("routeToCliRunner — new model prefixes", () => {
       [{ role: "user", content: "hi" }],
       5000
     );
-    expect(result).toBe("routed output");
+    expect(result).toEqual({ content: "routed output" });
     expect(mockSpawn).toHaveBeenCalledWith("pi", expect.any(Array), expect.any(Object));
   });
 

package/test/cli-runner.test.ts

@@ -123,7 +123,7 @@ describe("formatPrompt", () => {
     expect(result).toContain("Part two");
   });
 
-  it("ignores non-text ContentParts (e.g. image)", () => {
+  it("includes placeholder for non-text ContentParts (e.g. image)", () => {
     const result = formatPrompt([
       {
         role: "user",
@@ -133,7 +133,8 @@ describe("formatPrompt", () => {
         ],
       },
     ]);
-    expect(result).toBe("describe this");
+    expect(result).toContain("describe this");
+    expect(result).toContain("[Attached image");
   });
 
   it("coerces plain object content to JSON string (not [object Object])", () => {

package/test/proxy-e2e.test.ts

@@ -71,8 +71,11 @@ vi.mock("../src/cli-runner.js", async (importOriginal) => {
       if (!normalized.startsWith("cli-gemini/") && !normalized.startsWith("cli-claude/") && !normalized.startsWith("openai-codex/") && !normalized.startsWith("opencode/") && !normalized.startsWith("pi/")) {
         throw new Error(`Unknown CLI bridge model: "${model}"`);
       }
-      return `Mock response from ${normalized}`;
+      // Returns CliToolResult (content + optional tool_calls)
+      return { content: `Mock response from ${normalized}` };
     }),
+    extractMultimodalParts: vi.fn((messages: unknown[]) => ({ cleanMessages: messages, mediaFiles: [] })),
+    cleanupMediaFiles: vi.fn(),
   };
 });
 
@@ -444,29 +447,29 @@ describe("Error handling", () => {
 // Tool/function call rejection for CLI-proxy models
 // ──────────────────────────────────────────────────────────────────────────────
 
-describe("Tool call rejection", () => {
-  it("rejects tools for cli-gemini models with tools_not_supported", async () => {
+describe("Tool call support", () => {
+  it("accepts tools for cli-gemini models (200)", async () => {
     const res = await json("/v1/chat/completions", {
       model: "cli-gemini/gemini-2.5-pro",
       messages: [{ role: "user", content: "hi" }],
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
 
-    expect(res.status).toBe(400);
+    expect(res.status).toBe(200);
     const body = JSON.parse(res.body);
-    expect(body.error.code).toBe("tools_not_supported");
+    expect(body.choices[0].message.content).toBeDefined();
   });
 
-  it("rejects tools for cli-claude models with tools_not_supported", async () => {
+  it("accepts tools for cli-claude models (200)", async () => {
     const res = await json("/v1/chat/completions", {
       model: "cli-claude/claude-sonnet-4-6",
       messages: [{ role: "user", content: "hi" }],
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
 
-    expect(res.status).toBe(400);
+    expect(res.status).toBe(200);
     const body = JSON.parse(res.body);
-    expect(body.error.code).toBe("tools_not_supported");
+    expect(body.choices[0].message.content).toBeDefined();
   });
 
   it("does NOT reject tools for web-grok models (returns 503 no session)", async () => {
@@ -476,7 +479,7 @@ describe("Tool call rejection", () => {
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
 
-    // Should NOT be 400 tools_not_supported — reaches provider logic, gets 503 (no session)
+    // Reaches provider logic, gets 503 (no session)
     expect(res.status).not.toBe(400);
     expect(res.status).toBe(503);
     const body = JSON.parse(res.body);
@@ -489,23 +492,23 @@ describe("Tool call rejection", () => {
 // ──────────────────────────────────────────────────────────────────────────────
 
 describe("Model capabilities", () => {
-  it("cli-gemini models have capabilities.tools===false", async () => {
+  it("cli-gemini models have capabilities.tools===true", async () => {
     const res = await fetch("/v1/models");
     const body = JSON.parse(res.body);
     const cliGeminiModels = body.data.filter((m: { id: string }) => m.id.startsWith("cli-gemini/"));
     expect(cliGeminiModels.length).toBeGreaterThan(0);
     for (const m of cliGeminiModels) {
-      expect(m.capabilities.tools).toBe(false);
+      expect(m.capabilities.tools).toBe(true);
     }
   });
 
-  it("cli-claude models have capabilities.tools===false", async () => {
+  it("cli-claude models have capabilities.tools===true", async () => {
     const res = await fetch("/v1/models");
     const body = JSON.parse(res.body);
     const cliClaudeModels = body.data.filter((m: { id: string }) => m.id.startsWith("cli-claude/"));
     expect(cliClaudeModels.length).toBeGreaterThan(0);
     for (const m of cliClaudeModels) {
-      expect(m.capabilities.tools).toBe(false);
+      expect(m.capabilities.tools).toBe(true);
     }
   });
 
@@ -519,33 +522,33 @@ describe("Model capabilities", () => {
     }
   });
 
-  it("openai-codex models have capabilities.tools===false", async () => {
+  it("openai-codex models have capabilities.tools===true", async () => {
     const res = await fetch("/v1/models");
     const body = JSON.parse(res.body);
     const codexModels = body.data.filter((m: { id: string }) => m.id.startsWith("openai-codex/"));
     expect(codexModels.length).toBeGreaterThan(0);
     for (const m of codexModels) {
-      expect(m.capabilities.tools).toBe(false);
+      expect(m.capabilities.tools).toBe(true);
     }
   });
 
-  it("opencode models have capabilities.tools===false", async () => {
+  it("opencode models have capabilities.tools===true", async () => {
     const res = await fetch("/v1/models");
     const body = JSON.parse(res.body);
     const ocModels = body.data.filter((m: { id: string }) => m.id.startsWith("opencode/"));
     expect(ocModels.length).toBeGreaterThan(0);
     for (const m of ocModels) {
-      expect(m.capabilities.tools).toBe(false);
+      expect(m.capabilities.tools).toBe(true);
     }
   });
 
-  it("pi models have capabilities.tools===false", async () => {
+  it("pi models have capabilities.tools===true", async () => {
     const res = await fetch("/v1/models");
     const body = JSON.parse(res.body);
     const piModels = body.data.filter((m: { id: string }) => m.id.startsWith("pi/"));
     expect(piModels.length).toBeGreaterThan(0);
     for (const m of piModels) {
-      expect(m.capabilities.tools).toBe(false);
+      expect(m.capabilities.tools).toBe(true);
     }
   });
 });
@@ -585,34 +588,34 @@ describe("POST /v1/chat/completions — new model prefixes", () => {
     expect(body.choices[0].message.content).toBe("Mock response from pi/default");
   });
 
-  it("rejects tools for openai-codex models", async () => {
+  it("accepts tools for openai-codex models", async () => {
     const res = await json("/v1/chat/completions", {
       model: "openai-codex/gpt-5.3-codex",
       messages: [{ role: "user", content: "hi" }],
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
-    expect(res.status).toBe(400);
-    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+    expect(res.status).toBe(200);
+    expect(JSON.parse(res.body).choices[0].message.content).toBeDefined();
   });
 
-  it("rejects tools for opencode models", async () => {
+  it("accepts tools for opencode models", async () => {
     const res = await json("/v1/chat/completions", {
       model: "opencode/default",
       messages: [{ role: "user", content: "hi" }],
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
-    expect(res.status).toBe(400);
-    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+    expect(res.status).toBe(200);
+    expect(JSON.parse(res.body).choices[0].message.content).toBeDefined();
   });
 
-  it("rejects tools for pi models", async () => {
+  it("accepts tools for pi models", async () => {
     const res = await json("/v1/chat/completions", {
       model: "pi/default",
       messages: [{ role: "user", content: "hi" }],
       tools: [{ type: "function", function: { name: "test", parameters: {} } }],
     });
-    expect(res.status).toBe(400);
-    expect(JSON.parse(res.body).error.code).toBe("tools_not_supported");
+    expect(res.status).toBe(200);
+    expect(JSON.parse(res.body).choices[0].message.content).toBeDefined();
   });
 });