coc-bridge 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -7,6 +7,16 @@ Versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ---
 
+## [1.0.2] — 2026-10-14
+
+### Added
+- **Claude Code Tool Control**: Claude Code now retains 100% control of tool execution (`View`, `Edit`, `Bash`, `Glob`, `Grep`, `Write`), showing interactive diffs, user permission confirmations, and spinners instead of OpenCode silently intercepting them
+- **Anthropic `tool_use` Event Streaming**: Bridges model responses directly to Anthropic SSE tool use events (`content_block_start`, `input_json_delta`, `message_delta` with `stop_reason: "tool_use"`)
+- **Accurate Real-Time Token Counts**: Extracted directly from model execution metrics rather than estimated token formulas
+- **`coc-bridge restore` command**: One-command rollback to revert Claude Code & VS Code back to official Anthropic defaults with zero friction
+- **Automatic VS Code Settings**: Configures Claude Code VS Code extension settings with robust JSONC comment-stripping support
+- **`coc-bridge models` & `coc-bridge use <id>`**: Live discovery and switching of default models saved to `~/.coc-bridge/config.json`
+
 ## [1.0.1] — 2026-10-14
 
 ### Fixed

package/bin/coc-bridge.js

@@ -302,9 +302,10 @@ ${BOLD}COMMANDS${RESET}
   ${G}status${RESET}       Show whether the bridge is running
   ${G}logs${RESET}         Tail the live log file
   ${G}models${RESET}       List all available OpenCode models
-  ${G}use <id>${RESET}     Set the default model (saved to ~/.coc-bridge/config.json)
-  ${G}server${RESET}       Run in the foreground (useful for debugging)
-  ${G}setup${RESET}        Wire Claude Code to auto-start the bridge on login
+  ${G}use <id>${RESET}     Switch default model (saves to ~/.coc-bridge/config.json)
+  ${G}server${RESET}       Run in foreground (useful for debugging)
+  ${G}setup${RESET}        Wire Claude Code & VS Code to use the bridge
+  ${G}restore${RESET}      Revert Claude Code & VS Code back to official defaults
   ${G}doctor${RESET}       Check that Node, opencode, and claude are all wired up
 
 ${BOLD}ENVIRONMENT VARIABLES${RESET}
@@ -321,7 +322,8 @@ ${BOLD}EXAMPLES${RESET}
   coc-bridge stop                        # Shut it down
   coc-bridge status                      # Is it running?
   coc-bridge logs                        # Watch live logs
-  coc-bridge setup                       # One-time Claude Code wiring
+  coc-bridge setup                       # Wire Claude Code & VS Code
+  coc-bridge restore                     # Revert back to official Claude Code
   BRIDGE_PORT=5000 coc-bridge            # Custom port
 `);
 }
@@ -339,8 +341,9 @@ const cmd = process.argv[2] || 'start';
     case 'server':    cmdServer();                   break;
     case 'models':    cmdModels();                   break;
     case 'use':       cmdUse(process.argv[3]);       break;
-    case 'setup':     require(path.join(__dirname, '..', 'scripts', 'setup-claude.js')); break;
-    case 'doctor':    require(path.join(__dirname, '..', 'scripts', 'doctor.js'));       break;
+    case 'setup':     require(path.join(__dirname, '..', 'scripts', 'setup-claude.js'));   break;
+    case 'restore':   require(path.join(__dirname, '..', 'scripts', 'restore-claude.js')); break;
+    case 'doctor':    require(path.join(__dirname, '..', 'scripts', 'doctor.js'));         break;
     case '--version':
     case '-v': {
       const pkg = require('../package.json');

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "coc-bridge",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A zero-dependency local bridge that connects Claude Code to OpenCode's free hosted models — no API keys required.",
   "main": "src/server.js",
   "bin": {
-    "coc-bridge": "./bin/coc-bridge.js",
-    "coc-bridge-start": "./bin/coc-bridge.js"
+    "coc-bridge": "bin/coc-bridge.js",
+    "coc-bridge-start": "bin/coc-bridge.js"
   },
   "scripts": {
     "start": "node src/server.js",

package/scripts/restore-claude.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * coc-bridge restore — Reverts Claude Code and VS Code back to normal official settings.
+ * Removes all coc-bridge proxies, wrappers, and custom settings with zero friction.
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+const GREEN  = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED    = '\x1b[31m';
+const RESET  = '\x1b[0m';
+const BOLD   = '\x1b[1m';
+const DIM    = '\x1b[2m';
+
+function ok(msg)   { console.log(`${GREEN}  ✔${RESET}  ${msg}`); }
+function warn(msg) { console.log(`${YELLOW}  ⚠${RESET}  ${msg}`); }
+function info(msg) { console.log(`${DIM}  ℹ  ${msg}${RESET}`); }
+function step(msg) { console.log(`\n${BOLD}${msg}${RESET}`); }
+
+console.log(`\n${BOLD}coc-bridge restore 🔄${RESET}`);
+console.log(`${DIM}Reverting Claude Code & VS Code back to official Anthropic defaults...${RESET}`);
+
+// ─────────────────────────────────────────────
+// 1. Stop running bridge daemon
+// ─────────────────────────────────────────────
+step('1. Stopping coc-bridge daemon...');
+try {
+  const pidFile = path.join(os.homedir(), '.coc-bridge', 'bridge.pid');
+  if (fs.existsSync(pidFile)) {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+    if (pid) {
+      process.kill(pid, 'SIGTERM');
+      ok(`Terminated bridge process (PID ${pid})`);
+    }
+    fs.unlinkSync(pidFile);
+  } else {
+    info('Bridge is not running.');
+  }
+} catch (_) {
+  info('Bridge stopped or already inactive.');
+}
+
+// ─────────────────────────────────────────────
+// 2. Restore claude binary wrapper
+// ─────────────────────────────────────────────
+step('2. Restoring official claude binary...');
+let claudeBin;
+try {
+  claudeBin = execSync('which claude', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+} catch (_) {}
+
+if (claudeBin) {
+  const claudeBinReal = claudeBin + '-bin';
+  if (fs.existsSync(claudeBinReal)) {
+    // Overwrite the wrapper with the original executable
+    fs.copyFileSync(claudeBinReal, claudeBin);
+    fs.chmodSync(claudeBin, 0o755);
+    fs.unlinkSync(claudeBinReal);
+    ok(`Restored original binary at ${claudeBin}`);
+  } else {
+    // Check if the current file is a wrapper without backup
+    const content = fs.readFileSync(claudeBin, 'utf8');
+    if (content.includes('coc-bridge') || content.includes('ANTHROPIC_BASE_URL')) {
+      warn(`Claude wrapper detected, but backup binary ${claudeBinReal} was missing.`);
+      info('You can reinstall Claude Code cleanly via: npm install -g @anthropic-ai/claude-code');
+    } else {
+      ok(`Official claude binary is already in place (${claudeBin})`);
+    }
+  }
+} else {
+  info('claude binary not found in PATH.');
+}
+
+// ─────────────────────────────────────────────
+// 3. Clean VS Code settings
+// ─────────────────────────────────────────────
+step('3. Restoring VS Code settings...');
+
+const vsCodeCandidates = [
+  path.join(os.homedir(), '.config', 'Code', 'User', 'settings.json'),
+  path.join(os.homedir(), '.var', 'app', 'com.visualstudio.code', 'config', 'Code', 'User', 'settings.json'),
+  path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+  process.env.APPDATA ? path.join(process.env.APPDATA, 'Code', 'User', 'settings.json') : null
+].filter(Boolean);
+
+let vsCodeUpdated = false;
+for (const settingsPath of vsCodeCandidates) {
+  if (fs.existsSync(settingsPath)) {
+    try {
+      let raw = fs.readFileSync(settingsPath, 'utf8');
+      let cleaned = false;
+
+      // Clean using stripJsonComments + JSON parse
+      try {
+        const stripJsonComments = str => str.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? '' : m);
+        const json = JSON.parse(stripJsonComments(raw));
+        if (json['claudeCode.claudeProcessWrapper']) {
+          delete json['claudeCode.claudeProcessWrapper'];
+          cleaned = true;
+        }
+        if (json['claudeCode.environmentVariables']) {
+          // Remove bridge-injected variables
+          json['claudeCode.environmentVariables'] = json['claudeCode.environmentVariables'].filter(item => {
+            return !item.name.startsWith('ANTHROPIC_') && !item.name.startsWith('CLAUDE_CODE_');
+          });
+          if (json['claudeCode.environmentVariables'].length === 0) {
+            delete json['claudeCode.environmentVariables'];
+          }
+          cleaned = true;
+        }
+        if (cleaned) {
+          fs.writeFileSync(settingsPath, JSON.stringify(json, null, 4));
+          ok(`Restored VS Code settings: ${settingsPath}`);
+          vsCodeUpdated = true;
+        }
+      } catch (jsonErr) {
+        // If file contains JSON comments, strip wrapper lines with regex
+        raw = raw.replace(/"claudeCode\.claudeProcessWrapper":\s*"[^"]*",?/g, '');
+        fs.writeFileSync(settingsPath, raw);
+        ok(`Cleaned wrapper lines in: ${settingsPath}`);
+        vsCodeUpdated = true;
+      }
+    } catch (e) {
+      warn(`Could not update ${settingsPath}: ${e.message}`);
+    }
+  }
+}
+
+if (!vsCodeUpdated) {
+  info('No VS Code bridge overrides were found.');
+}
+
+// ─────────────────────────────────────────────
+// Done
+// ─────────────────────────────────────────────
+console.log(`
+${GREEN}${BOLD}✔ Successfully restored!${RESET}
+
+  Claude Code and VS Code are now back to normal official Anthropic mode.
+  No proxies or custom wrappers are active.
+
+  ${DIM}Want coc-bridge back anytime? Just run:${RESET}
+    ${BOLD}coc-bridge setup${RESET}
+`);

package/scripts/setup-claude.js

@@ -137,16 +137,82 @@ if (!fs.existsSync(logDir)) {
   ok(`Log dir exists: ${logDir}`);
 }
 
+// ─────────────────────────────────────────────
+// 5. Configure VS Code extension automatically
+// ─────────────────────────────────────────────
+step('5. Configuring VS Code Claude Code extension...');
+
+const vsCodeCandidates = [
+  path.join(os.homedir(), '.config', 'Code', 'User', 'settings.json'),
+  path.join(os.homedir(), '.var', 'app', 'com.visualstudio.code', 'config', 'Code', 'User', 'settings.json'),
+  path.join(os.homedir(), 'Library', 'Application Support', 'Code', 'User', 'settings.json'),
+  process.env.APPDATA ? path.join(process.env.APPDATA, 'Code', 'User', 'settings.json') : null
+].filter(Boolean);
+
+let vsCodeConfigured = false;
+for (const settingsPath of vsCodeCandidates) {
+  if (fs.existsSync(settingsPath)) {
+    try {
+      const raw = fs.readFileSync(settingsPath, 'utf8');
+      const stripJsonComments = str => str.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? '' : m);
+      const settings = JSON.parse(stripJsonComments(raw));
+
+      settings['claudeCode.claudeProcessWrapper'] = claudeBin;
+      settings['claudeCode.environmentVariables'] = [
+        { name: 'ANTHROPIC_BASE_URL', value: 'http://127.0.0.1:4045' },
+        { name: 'ANTHROPIC_AUTH_TOKEN', value: 'coc-local' },
+        { name: 'ANTHROPIC_API_KEY', value: '' },
+        { name: 'CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT', value: '1' },
+        { name: 'CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY', value: '1' },
+        { name: 'ANTHROPIC_MODEL', value: 'opencode/space-bunny-free' },
+        { name: 'ANTHROPIC_CUSTOM_MODEL_OPTION_NAME', value: 'Space Bunny' },
+        { name: 'ANTHROPIC_DEFAULT_OPUS_MODEL', value: 'opencode/nemotron-3-ultra-free' },
+        { name: 'ANTHROPIC_DEFAULT_OPUS_MODEL_NAME', value: 'Nemotron 3 Ultra' },
+        { name: 'ANTHROPIC_DEFAULT_SONNET_MODEL', value: 'opencode/muse-spark-1.3-contributor-free' },
+        { name: 'ANTHROPIC_DEFAULT_SONNET_MODEL_NAME', value: 'Muse Spark 1.3' },
+        { name: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', value: 'opencode/cat-jam-free' },
+        { name: 'ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME', value: 'Cat Jam' },
+        { name: 'ANTHROPIC_DEFAULT_FABLE_MODEL', value: 'opencode/ling-3.1-flash-free' },
+        { name: 'ANTHROPIC_DEFAULT_FABLE_MODEL_NAME', value: 'Ling 3.1 Flash' }
+      ];
+
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 4));
+      ok(`Configured VS Code: ${settingsPath}`);
+      vsCodeConfigured = true;
+    } catch (e) {
+      warn(`Could not automatically update ${settingsPath}: ${e.message}`);
+    }
+  }
+}
+
+if (!vsCodeConfigured) {
+  warn('VS Code settings not found. If using VS Code, set "claudeCode.claudeProcessWrapper": "' + claudeBin + '"');
+}
+
+// ─────────────────────────────────────────────
+// 6. Ensure ~/.local/bin symlink exists
+// ─────────────────────────────────────────────
+step('6. Ensuring CLI command availability...');
+try {
+  const localBin = path.join(os.homedir(), '.local', 'bin');
+  if (!fs.existsSync(localBin)) fs.mkdirSync(localBin, { recursive: true });
+  const targetLink = path.join(localBin, 'coc-bridge');
+  if (bridgeBin && !fs.existsSync(targetLink)) {
+    fs.symlinkSync(bridgeBin, targetLink);
+    ok(`Linked coc-bridge to ${targetLink}`);
+  }
+} catch (_) {}
+
 // ─────────────────────────────────────────────
 // Done
 // ─────────────────────────────────────────────
 console.log(`
 ${GREEN}${BOLD}✅  Setup complete!${RESET}
 
-  Run ${BOLD}claude${RESET} as normal — coc-bridge will auto-start in the background.
-
-  Verify anytime with:
-    ${BOLD}coc-bridge doctor${RESET}
+  • Terminal: Run ${BOLD}claude${RESET} as normal — coc-bridge auto-starts in background.
+  • VS Code : Open the Claude Code extension — models are connected!
+  • Switch models: ${BOLD}coc-bridge models${RESET} / ${BOLD}coc-bridge use <id>${RESET}
+  • Want normal Claude back? Run: ${BOLD}coc-bridge restore${RESET}
 
   Logs: ${logDir}/bridge.log
 `);

package/src/server.js

@@ -9,6 +9,8 @@ const fs     = require('fs');
 const PORT             = parseInt(process.env.BRIDGE_PORT || process.env.PORT || '4045', 10);
 const MAX_PAYLOAD_BYTES = 50 * 1024 * 1024; // 50MB
 const CONFIG_FILE      = path.join(os.homedir(), '.coc-bridge', 'config.json');
+const SANDBOX_DIR      = path.join(os.tmpdir(), 'coc-bridge-sandbox');
+try { fs.mkdirSync(SANDBOX_DIR, { recursive: true }); } catch (_) {}
 
 // ─── Config (persists user's chosen default model) ────────────────────────────
 function readConfig() {
@@ -126,60 +128,174 @@ function resolveModel(requested) {
 
 
 /**
- * Convert Anthropic message format into a clean prompt string for OpenCode CLI
+ * Extract tool calls from model output.
+ * Supports:
+ *  1. ```tool_call ... ``` or ```json ... ``` blocks
+ *  2. <tool_call> ... </tool_call> XML tags
+ *  3. Bare JSON object containing "name" and "input" matching an allowed tool
+ */
+function extractToolCalls(text, allowedTools = []) {
+  if (!text) return { text: '', toolCalls: [] };
+  const toolCalls = [];
+
+  // 1. Match markdown blocks
+  const blockRegex = /```(?:tool_call|json)?\s*\n?([\s\S]*?)\n?```/gi;
+  let match;
+  let textSegments = [];
+  let lastIndex = 0;
+
+  while ((match = blockRegex.exec(text)) !== null) {
+    let isTool = false;
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed && typeof parsed.name === 'string' && parsed.input !== undefined) {
+        const matchedTool = allowedTools.length === 0
+          ? parsed.name
+          : allowedTools.find(t => t.toLowerCase() === parsed.name.toLowerCase());
+        if (matchedTool) {
+          toolCalls.push({ name: matchedTool, input: parsed.input });
+          textSegments.push(text.slice(lastIndex, match.index));
+          lastIndex = blockRegex.lastIndex;
+          isTool = true;
+        }
+      }
+    } catch (_) {}
+  }
+
+  if (toolCalls.length > 0) {
+    textSegments.push(text.slice(lastIndex));
+    const cleanText = textSegments.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+    return { text: cleanText, toolCalls };
+  }
+
+  // 2. Match <tool_call> tags
+  const xmlRegex = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gi;
+  lastIndex = 0;
+  textSegments = [];
+  while ((match = xmlRegex.exec(text)) !== null) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed && typeof parsed.name === 'string' && parsed.input !== undefined) {
+        const matchedTool = allowedTools.length === 0
+          ? parsed.name
+          : allowedTools.find(t => t.toLowerCase() === parsed.name.toLowerCase());
+        if (matchedTool) {
+          toolCalls.push({ name: matchedTool, input: parsed.input });
+          textSegments.push(text.slice(lastIndex, match.index));
+          lastIndex = xmlRegex.lastIndex;
+        }
+      }
+    } catch (_) {}
+  }
+
+  if (toolCalls.length > 0) {
+    textSegments.push(text.slice(lastIndex));
+    const cleanText = textSegments.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+    return { text: cleanText, toolCalls };
+  }
+
+  // 3. Match bare JSON object with "name" and "input"
+  const bareMatch = text.match(/(\{\s*"name"\s*:\s*"[^"]+"\s*,\s*"input"\s*:\s*\{[\s\S]*?\}\s*\})/);
+  if (bareMatch) {
+    try {
+      const parsed = JSON.parse(bareMatch[1].trim());
+      if (parsed && typeof parsed.name === 'string' && parsed.input !== undefined) {
+        const matchedTool = allowedTools.length === 0
+          ? parsed.name
+          : allowedTools.find(t => t.toLowerCase() === parsed.name.toLowerCase());
+        if (matchedTool) {
+          const pre = text.slice(0, bareMatch.index).trim();
+          const post = text.slice(bareMatch.index + bareMatch[1].length).trim();
+          return {
+            text: [pre, post].filter(Boolean).join('\n'),
+            toolCalls: [{ name: matchedTool, input: parsed.input }]
+          };
+        }
+      }
+    } catch (_) {}
+  }
+
+  return { text: text.trim(), toolCalls: [] };
+}
+
+/**
+ * Convert Anthropic message format into a clean prompt string for OpenCode CLI,
+ * with full tool schemas injected so Claude Code controls tool execution.
  */
 function buildPrompt(body) {
   let promptParts = [];
+  const allowedTools = [];
+
+  // 1. Tool schemas and instructions
+  if (Array.isArray(body.tools) && body.tools.length > 0) {
+    let toolsDesc = '## Available Tools & Instructions\n';
+    toolsDesc += 'You are acting as the AI model for Claude Code. You do NOT have any built-in tools or direct filesystem access.\n';
+    toolsDesc += 'Do NOT attempt to use any internal OpenCode tools (like read, glob, shell, or edit).\n';
+    toolsDesc += 'Instead, to view files, make edits, run terminal commands, or list directories, you MUST emit a tool call in this exact JSON block:\n\n';
+    toolsDesc += '```tool_call\n';
+    toolsDesc += '{"name": "<ToolName>", "input": { ...arguments according to input schema... }}\n';
+    toolsDesc += '```\n\n';
+    toolsDesc += 'Claude Code will execute the tool on the user\'s local machine and return the result to you in the next message.\n';
+    toolsDesc += 'When you have enough information to answer the user without tools, reply with your normal explanation and NO tool_call blocks.\n\n';
+    toolsDesc += 'Tools available to request:\n';
+
+    for (const tool of body.tools) {
+      if (tool && tool.name) {
+        allowedTools.push(tool.name);
+        toolsDesc += `\n### Tool: ${tool.name}\n`;
+        if (tool.description) toolsDesc += `Description: ${tool.description}\n`;
+        if (tool.input_schema) toolsDesc += `Input Schema: ${JSON.stringify(tool.input_schema)}\n`;
+      }
+    }
+
+    promptParts.push(`[System Instructions & Tools]\n${toolsDesc}\n`);
+  }
 
-  // Add system instruction if present
+  // 2. Add system prompt from Claude Code
   if (body.system) {
+    let sysText = '';
     if (typeof body.system === 'string') {
-      promptParts.push(`[System Instructions]\n${body.system}\n`);
+      sysText = body.system;
     } else if (Array.isArray(body.system)) {
-      const sysText = body.system.map(s => s.text || '').join('\n');
-      if (sysText.trim()) {
-        promptParts.push(`[System Instructions]\n${sysText}\n`);
-      }
+      sysText = body.system.map(s => (typeof s === 'string' ? s : (s.text || ''))).join('\n');
+    }
+    if (sysText.trim()) {
+      promptParts.push(`[Claude Code Instructions]\n${sysText.trim()}\n`);
     }
   }
 
-  // Add messages history
+  // 3. Add message history
   if (Array.isArray(body.messages)) {
     for (const msg of body.messages) {
       const role = msg.role === 'assistant' ? 'Assistant' : 'User';
-      let content = '';
 
       if (typeof msg.content === 'string') {
-        content = msg.content;
+        promptParts.push(`${role}: ${msg.content.trim()}`);
       } else if (Array.isArray(msg.content)) {
-        content = msg.content
-          .map(part => {
-            if (part.type === 'text') {
-              return part.text || '';
-            }
-            if (part.type === 'tool_use') {
-              const input = typeof part.input === 'object' ? JSON.stringify(part.input) : (part.input || '');
-              return `[Executed Tool: ${part.name}(${input})]`;
-            }
-            if (part.type === 'tool_result') {
-              const resContent = typeof part.content === 'string' ? part.content : JSON.stringify(part.content || '');
-              return `[Tool Result: ${resContent}]`;
-            }
-            return '';
-          })
-          .filter(Boolean)
-          .join('\n');
-      }
-
-      if (content.trim()) {
-        promptParts.push(`${role}: ${content}`);
+        let textParts = [];
+        for (const part of msg.content) {
+          if (part.type === 'text' && part.text) {
+            textParts.push(part.text);
+          } else if (part.type === 'tool_use') {
+            textParts.push(`\`\`\`tool_call\n${JSON.stringify({ name: part.name, input: part.input })}\n\`\`\``);
+          } else if (part.type === 'tool_result') {
+            const resContent = typeof part.content === 'string'
+              ? part.content
+              : (Array.isArray(part.content)
+                  ? part.content.map(c => c.text || JSON.stringify(c)).join('\n')
+                  : JSON.stringify(part.content || ''));
+            textParts.push(`[Tool Result for ${part.tool_use_id || 'tool'}]:\n${resContent}`);
+          }
+        }
+        if (textParts.length > 0) {
+          promptParts.push(`${role}: ${textParts.join('\n\n')}`);
+        }
       }
     }
   }
 
-  // If there's an agent prompt turn, make sure Assistant is ready to answer
   promptParts.push('Assistant:');
-  return promptParts.join('\n\n');
+  return { prompt: promptParts.join('\n\n'), allowedTools };
 }
 
 /**
@@ -196,14 +312,15 @@ function handleMessagesRequest(req, res, reqBody) {
   }
 
   const modelName = resolveModel(body.model);
-  const prompt = buildPrompt(body);
+  const { prompt, allowedTools } = buildPrompt(body);
   const isStreaming = Boolean(body.stream);
   const messageId = `msg_${crypto.randomBytes(12).toString('hex')}`;
 
-  console.log(`[Bridge] Incoming request for model: ${modelName} (requested: ${body.model || 'none'}, streaming=${isStreaming})`);
+  console.log(`[Bridge] Request: ${modelName} (tools: ${allowedTools.length}, streaming=${isStreaming})`);
 
-  // Spawn OpenCode CLI as child process
-  const child = spawn(OPENCODE_BIN, ['run', '-m', modelName], {
+  // Run in empty sandbox dir so OpenCode cannot touch user files directly
+  const child = spawn(OPENCODE_BIN, ['run', '-m', modelName, '--format', 'json'], {
+    cwd: SANDBOX_DIR,
     stdio: ['pipe', 'pipe', 'pipe'],
     env: { ...process.env }
   });
@@ -226,108 +343,185 @@ function handleMessagesRequest(req, res, reqBody) {
     }
   });
 
-  // Write prompt to stdin and close
   child.stdin.write(prompt);
   child.stdin.end();
 
-  let accumulatedOutput = '';
+  let stdoutBuffer = '';
+  let accumulatedText = '';
   let accumulatedError = '';
+  let reportedTokens = null;
+
+  child.stdout.on('data', chunk => {
+    stdoutBuffer += chunk.toString();
+    const lines = stdoutBuffer.split('\n');
+    stdoutBuffer = lines.pop(); // keep partial line
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === 'text' && ev.part && typeof ev.part.text === 'string') {
+          accumulatedText += ev.part.text;
+        } else if (ev.type === 'step_finish' && ev.part && ev.part.tokens) {
+          reportedTokens = ev.part.tokens;
+        }
+      } catch (_) {
+        accumulatedText += line + '\n';
+      }
+    }
+  });
 
-  if (isStreaming) {
-    // Anthropic SSE headers
-    res.writeHead(200, {
-      'Content-Type': 'text/event-stream; charset=utf-8',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive'
-    });
+  child.stderr.on('data', chunk => {
+    accumulatedError += chunk.toString();
+  });
 
-    // 1. message_start
-    res.write(`event: message_start\ndata: ${JSON.stringify({
-      type: 'message_start',
-      message: {
-        id: messageId,
-        type: 'message',
-        role: 'assistant',
-        model: modelName,
-        content: [],
-        stop_reason: null,
-        stop_sequence: null,
-        usage: { input_tokens: Math.ceil(prompt.length / 4), output_tokens: 1 }
-      }
-    })}\n\n`);
-
-    // 2. content_block_start
-    res.write(`event: content_block_start\ndata: ${JSON.stringify({
-      type: 'content_block_start',
-      index: 0,
-      content_block: { type: 'text', text: '' }
-    })}\n\n`);
-
-    // Stream chunks as they arrive from OpenCode stdout
-    child.stdout.on('data', chunk => {
-      const text = chunk.toString();
-      accumulatedOutput += text;
-      res.write(`event: content_block_delta\ndata: ${JSON.stringify({
-        type: 'content_block_delta',
-        index: 0,
-        delta: { type: 'text_delta', text: text }
-      })}\n\n`);
-    });
+  child.on('close', code => {
+    clearTimeout(timer);
 
-    child.stderr.on('data', chunk => {
-      accumulatedError += chunk.toString();
-    });
+    // Process any remaining buffered stdout
+    if (stdoutBuffer.trim()) {
+      try {
+        const ev = JSON.parse(stdoutBuffer);
+        if (ev.type === 'text' && ev.part && typeof ev.part.text === 'string') {
+          accumulatedText += ev.part.text;
+        } else if (ev.type === 'step_finish' && ev.part && ev.part.tokens) {
+          reportedTokens = ev.part.tokens;
+        }
+      } catch (_) {
+        accumulatedText += stdoutBuffer;
+      }
+    }
 
-    child.on('close', code => {
-      clearTimeout(timer);
-      if (code !== 0 && !accumulatedOutput.trim()) {
-        console.error(`[Bridge] OpenCode exited with code ${code}: ${accumulatedError}`);
-        const errMsg = accumulatedError.trim() || `OpenCode CLI process exited with code ${code}`;
+    if (code !== 0 && !accumulatedText.trim()) {
+      console.error(`[Bridge] OpenCode exited with code ${code}: ${accumulatedError}`);
+      const errMsg = accumulatedError.trim() || `OpenCode process exited with code ${code}`;
+      if (isStreaming) {
+        res.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8' });
         res.write(`event: error\ndata: ${JSON.stringify({ type: 'error', error: { message: errMsg } })}\n\n`);
         res.end();
-        return;
+      } else {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: { type: 'api_error', message: errMsg } }));
       }
+      return;
+    }
 
-      // 3. content_block_stop
-      res.write(`event: content_block_stop\ndata: ${JSON.stringify({
-        type: 'content_block_stop',
-        index: 0
+    // Token accounting
+    const inputTokens = (reportedTokens && reportedTokens.input) || Math.ceil(prompt.length / 4);
+    const outputTokens = (reportedTokens && reportedTokens.output)
+      ? (reportedTokens.output + (reportedTokens.reasoning || 0))
+      : Math.ceil(accumulatedText.length / 4);
+
+    // Extract tool calls
+    const { text: cleanText, toolCalls } = extractToolCalls(accumulatedText, allowedTools);
+    const hasToolCalls = toolCalls.length > 0;
+    const stopReason = hasToolCalls ? 'tool_use' : 'end_turn';
+
+    if (isStreaming) {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream; charset=utf-8',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive'
+      });
+
+      // 1. message_start
+      res.write(`event: message_start\ndata: ${JSON.stringify({
+        type: 'message_start',
+        message: {
+          id: messageId,
+          type: 'message',
+          role: 'assistant',
+          model: modelName,
+          content: [],
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: inputTokens, output_tokens: 1 }
+        }
       })}\n\n`);
 
+      let blockIndex = 0;
+
+      // 2. Text block (if clean text exists)
+      if (cleanText.length > 0) {
+        res.write(`event: content_block_start\ndata: ${JSON.stringify({
+          type: 'content_block_start',
+          index: blockIndex,
+          content_block: { type: 'text', text: '' }
+        })}\n\n`);
+
+        res.write(`event: content_block_delta\ndata: ${JSON.stringify({
+          type: 'content_block_delta',
+          index: blockIndex,
+          delta: { type: 'text_delta', text: cleanText }
+        })}\n\n`);
+
+        res.write(`event: content_block_stop\ndata: ${JSON.stringify({
+          type: 'content_block_stop',
+          index: blockIndex
+        })}\n\n`);
+
+        blockIndex++;
+      }
+
+      // 3. Tool use blocks
+      for (const tc of toolCalls) {
+        const toolUseId = `toolu_${crypto.randomBytes(12).toString('hex')}`;
+
+        res.write(`event: content_block_start\ndata: ${JSON.stringify({
+          type: 'content_block_start',
+          index: blockIndex,
+          content_block: {
+            type: 'tool_use',
+            id: toolUseId,
+            name: tc.name,
+            input: {}
+          }
+        })}\n\n`);
+
+        res.write(`event: content_block_delta\ndata: ${JSON.stringify({
+          type: 'content_block_delta',
+          index: blockIndex,
+          delta: {
+            type: 'input_json_delta',
+            partial_json: JSON.stringify(tc.input)
+          }
+        })}\n\n`);
+
+        res.write(`event: content_block_stop\ndata: ${JSON.stringify({
+          type: 'content_block_stop',
+          index: blockIndex
+        })}\n\n`);
+
+        blockIndex++;
+      }
+
       // 4. message_delta
       res.write(`event: message_delta\ndata: ${JSON.stringify({
         type: 'message_delta',
-        delta: { stop_reason: 'end_turn', stop_sequence: null },
-        usage: { output_tokens: Math.ceil(accumulatedOutput.length / 4) }
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        usage: { output_tokens: outputTokens }
       })}\n\n`);
 
       // 5. message_stop
       res.write(`event: message_stop\ndata: ${JSON.stringify({ type: 'message_stop' })}\n\n`);
       res.end();
-    });
-
-  } else {
-    // Non-streaming response
-    child.stdout.on('data', chunk => {
-      accumulatedOutput += chunk.toString();
-    });
-
-    child.stderr.on('data', chunk => {
-      accumulatedError += chunk.toString();
-    });
 
-    child.on('close', code => {
-      clearTimeout(timer);
-      if (code !== 0 && !accumulatedOutput.trim()) {
-        console.error(`[Bridge] OpenCode exited with code ${code}: ${accumulatedError}`);
-        res.writeHead(500, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
-          error: {
-            type: 'api_error',
-            message: accumulatedError.trim() || `OpenCode CLI failed with exit code ${code}`
-          }
-        }));
-        return;
+    } else {
+      // Non-streaming response
+      const content = [];
+      if (cleanText.length > 0) {
+        content.push({ type: 'text', text: cleanText });
+      }
+      for (const tc of toolCalls) {
+        content.push({
+          type: 'tool_use',
+          id: `toolu_${crypto.randomBytes(12).toString('hex')}`,
+          name: tc.name,
+          input: tc.input
+        });
+      }
+      if (content.length === 0) {
+        content.push({ type: 'text', text: accumulatedText.trim() });
       }
 
       const responsePayload = {
@@ -335,24 +529,19 @@ function handleMessagesRequest(req, res, reqBody) {
         type: 'message',
         role: 'assistant',
         model: modelName,
-        content: [
-          {
-            type: 'text',
-            text: accumulatedOutput.trim()
-          }
-        ],
-        stop_reason: 'end_turn',
+        content,
+        stop_reason: stopReason,
         stop_sequence: null,
         usage: {
-          input_tokens: Math.ceil(prompt.length / 4),
-          output_tokens: Math.ceil(accumulatedOutput.length / 4)
+          input_tokens: inputTokens,
+          output_tokens: outputTokens
         }
       };
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(responsePayload));
-    });
-  }
+    }
+  });
 }
 
 // HTTP Server