@elvatis_com/openclaw-cli-bridge-elvatis 2.2.2 → 2.4.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.4.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.4.0 | ✅ Pushed to main |
+| npm | 2.4.0 | ⏳ Pending (via CI) |
+| ClawHub | 2.4.0 | ⏳ Pending (via CI) |
 <!-- /SECTION: release_state -->
 
 <!-- SECTION: open_tasks -->
@@ -31,7 +31,9 @@ _No open tasks._
 
 | Task | Title | Version |
 |------|-------|---------|
-| T-018 | Fix vllm apiKey corruption (401) + harden config-patcher | 2.2.2 |
+| T-020 | Metrics & health dashboard: request volume, latency, errors, token usage | 2.4.0 |
+| 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/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "2.2.2",
+  "version": "2.4.0",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "2.2.2",
+  "version": "2.4.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/metrics.ts

@@ -0,0 +1,85 @@
+/**
+ * metrics.ts
+ *
+ * In-memory metrics collector for the CLI bridge proxy.
+ * Tracks request counts, errors, latency, and token usage per model.
+ * All operations are O(1) — cannot block the event loop.
+ */
+
+export interface ModelMetrics {
+  model: string;
+  requests: number;
+  errors: number;
+  totalLatencyMs: number;
+  promptTokens: number;
+  completionTokens: number;
+  lastRequestAt: number | null;
+}
+
+export interface MetricsSnapshot {
+  startedAt: number;
+  totalRequests: number;
+  totalErrors: number;
+  models: ModelMetrics[]; // sorted by requests desc
+}
+
+class MetricsCollector {
+  private startedAt = Date.now();
+  private data = new Map<string, ModelMetrics>();
+
+  recordRequest(
+    model: string,
+    durationMs: number,
+    success: boolean,
+    promptTokens?: number,
+    completionTokens?: number,
+  ): void {
+    let entry = this.data.get(model);
+    if (!entry) {
+      entry = {
+        model,
+        requests: 0,
+        errors: 0,
+        totalLatencyMs: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+        lastRequestAt: null,
+      };
+      this.data.set(model, entry);
+    }
+    entry.requests++;
+    if (!success) entry.errors++;
+    entry.totalLatencyMs += durationMs;
+    if (promptTokens) entry.promptTokens += promptTokens;
+    if (completionTokens) entry.completionTokens += completionTokens;
+    entry.lastRequestAt = Date.now();
+  }
+
+  getMetrics(): MetricsSnapshot {
+    let totalRequests = 0;
+    let totalErrors = 0;
+    const models: ModelMetrics[] = [];
+
+    for (const entry of this.data.values()) {
+      totalRequests += entry.requests;
+      totalErrors += entry.errors;
+      models.push({ ...entry });
+    }
+
+    models.sort((a, b) => b.requests - a.requests);
+
+    return {
+      startedAt: this.startedAt,
+      totalRequests,
+      totalErrors,
+      models,
+    };
+  }
+
+  reset(): void {
+    this.startedAt = Date.now();
+    this.data.clear();
+  }
+}
+
+export const metrics = new MetricsCollector();