opencode-claude-code-wrapper 0.0.5 → 0.0.7

package/index.mjs

@@ -2,14 +2,11 @@ import { generatePKCE } from "@openauthjs/openauth/pkce";
 import { writeFileSync, appendFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import {
-  transformRequestToCLIArgs,
-  spawnClaudeCode,
-} from "./lib/cli-runner.mjs";
-import {
-  JSONLToSSETransformer,
-  buildCompleteResponse,
-} from "./lib/transformer.mjs";
+import * as fs from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { AcpClient } from "./lib/acp-protocol.mjs";
+import { AcpToSSETransformer } from "./lib/acp-transformer.mjs";
 
 const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 
@@ -280,6 +277,13 @@ async function handleClaudeCodeRequest(input, init) {
 
   // Log full request body to separate file for detailed inspection
   try {
+    // Save requests with tools to a separate file
+    if (requestBody.tools?.length > 0) {
+      writeFileSync(
+        join(METRICS_DIR, "last_request_with_tools.json"),
+        JSON.stringify(requestBody, null, 2)
+      );
+    }
     writeFileSync(
       join(METRICS_DIR, "last_request.json"),
       JSON.stringify(requestBody, null, 2)
@@ -298,33 +302,347 @@ async function handleClaudeCodeRequest(input, init) {
 }
 
 /**
- * OpenCode plugin that wraps Claude Code CLI with full auth options
+ * OpenCode plugin that wraps Claude Code via ACP protocol
  * @type {import('@opencode-ai/plugin').Plugin}
  */
 export async function ClaudeCodeWrapperPlugin({ client }) {
+  // Store ACP client instances per model
+  const acpClients = new Map();
+  const transformers = new Map();
+
   return {
     auth: {
       provider: "anthropic",
       async loader(getAuth, provider) {
         const auth = await getAuth();
 
-        // Claude Code CLI auth - zero cost, use CLI
-        // Detected by special key value: user enters "cli" or "claude-code" as API key
-        const isClaudeCodeCLI =
-          auth.type === "api" &&
-          (auth.key === "claude-code-cli" ||
-            auth.key === "cli" ||
-            auth.key === "claude-code" ||
-            auth.key === "cc");
-        if (isClaudeCodeCLI) {
-          for (const model of Object.values(provider.models)) {
-            model.cost = {
-              input: 0,
-              output: 0,
-              cache: { read: 0, write: 0 },
+        // Claude Code ACP agent handles auth internally
+        // We just need to provide zero-cost wrapper
+        for (const model of Object.values(provider.models)) {
+          model.cost = {
+            input: 0,
+            output: 0,
+            cache: { read: 0, write: 0 },
+          };
+        }
+
+        return {
+          apiKey: auth.key || "",
+          async fetch(input, init) {
+            const auth = await getAuth();
+
+            // Claude Code CLI - detected by special key
+            const isClaudeCodeCLI = auth.key === "claude-code" || auth.key === "cc";
+
+            if (isClaudeCodeCLI) {
+              try {
+                return await handleAcpRequest(input, init, auth);
+              } catch (error) {
+                console.error("[claude-code-acp] error:", error);
+                return createErrorResponse(error);
+              }
+            }
+
+            // OAuth auth (Claude Pro/Max) - pass through
+            if (auth.type === "oauth") {
+              return fetch(input, init);
+            }
+
+            // Default - no special handling
+            return fetch(input, init);
+          },
+        };
+      },
+      methods: [
+        {
+          label: "Claude Code (ACP)",
+          type: "api",
+          authorize: async () => {
+            return {
+              url: "https://console.anthropic.com/oauth/authorize",
+              instructions: "Use the ACP agent to authenticate via Claude Code",
+              method: "external",
+            };
+          },
+        },
+        {
+          label: "Claude Pro/Max (OAuth)",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("max");
+            return {
+              url: url,
+              instructions: "Paste authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                return credentials;
+              },
             };
+          },
+        },
+        {
+          label: "Create an API Key",
+          type: "oauth",
+          authorize: async () => {
+            const { url, verifier } = await authorize("console");
+            return {
+              url: url,
+              instructions: "Paste authorization code here: ",
+              method: "code",
+              callback: async (code) => {
+                const credentials = await exchange(code, verifier);
+                if (credentials.type === "failed") return credentials;
+                const result = await fetch(
+                  `https://api.anthropic.com/oauth/claude_cli/create_api_key`,
+                  {
+                    method: "POST",
+                    headers: {
+                      "Content-Type": "application/json",
+                      authorization: `Bearer ${credentials.access}`,
+                    },
+                  }
+                ).then((r) => r.json());
+                return { type: "success", key: result.raw_key };
+              },
+            };
+          },
+        },
+        {
+          provider: "anthropic",
+          label: "Manually enter API Key",
+          type: "api",
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * Handle request via ACP agent (claude-code-acp)
+ */
+async function handleAcpRequest(input, init, auth) {
+  // Get or create ACP client for this request
+  let requestBody;
+  try {
+    if (typeof input === "string" || input instanceof URL) {
+      const url = new URL(input.toString());
+      // Only handle /v1/messages endpoint via ACP
+      if (url.pathname !== "/v1/messages") {
+        return fetch(input, init);
+      }
+      requestBody = init?.body ? JSON.parse(init.body) : {};
+    } else if (input instanceof Request) {
+      const url = new URL(input.url);
+      if (url.pathname !== "/v1/messages") {
+        return fetch(input, init);
+      }
+      requestBody = init?.body ? JSON.parse(init.body) : await input.text();
+    } else {
+      return fetch(input, init);
+    }
+  } catch (e) {
+    return createErrorResponse(new Error("Invalid request"));
+  }
+
+  // Log incoming request
+  logMetric("request", {
+    model: requestBody.model,
+    stream: requestBody.stream,
+    system: requestBody.system ? (typeof requestBody.system === "string" ? requestBody.system.substring(0, 200) : "[array]") : null,
+    messages_count: requestBody.messages?.length,
+    tools_count: requestBody.tools?.length,
+  });
+
+  try {
+    // Get ACP client and transformer
+    const model = requestBody.model || "claude-sonnet-4-5-20250929";
+    let acpClient = acpClients.get(model);
+    let transformer = transformers.get(model);
+
+    if (!acpClient) {
+      acpClient = new AcpClient();
+      acpClients.set(model, acpClient);
+      await acpClient.connect();
+    }
+
+    if (!transformer) {
+      transformer = new AcpToSSETransformer();
+      transformers.set(model, transformer);
+    }
+
+    // Convert API request to ACP format
+    const resources = extractResources(requestBody.messages || []);
+    const text = extractUserText(requestBody.messages || []);
+
+    // Create new session if needed
+    if (!acpClient.sessionId) {
+      await acpClient.newSession({
+        mcpServers: extractMcpServers(auth),
+      });
+    }
+
+    const isStreaming = requestBody.stream === true;
+
+    // Send prompt to ACP
+    const response = await acpClient.prompt(text, resources);
+
+    if (isStreaming && response.body) {
+      // Transform streaming ACP responses to SSE
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      const encoder = new TextEncoder();
+
+      const stream = new ReadableStream({
+        async pull(controller) {
+          const { done, value } = await reader.read();
+          if (done) {
+            // Finalize transformer
+            const finalEvents = transformer.finalize();
+            controller.enqueue(encoder.encode(finalEvents));
+            controller.close();
+            return;
           }
 
+          const text = decoder.decode(value, { stream: true });
+          // Parse ndjson from ACP
+          const lines = text.split("\n").filter((line) => line.trim());
+
+          for (const line of lines) {
+            try {
+              const message = JSON.parse(line);
+              // Transform ACP message to SSE
+              const sseEvents = transformer.transformMessage(message);
+              if (sseEvents) {
+                controller.enqueue(encoder.encode(sseEvents));
+              }
+            } catch (e) {
+              // Skip malformed lines
+            }
+          }
+        },
+      });
+
+      return new Response(stream, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        },
+      });
+    } else {
+      return response;
+    }
+  } catch (error) {
+    console.error("[claude-code-acp] error:", error);
+    return createErrorResponse(error);
+  }
+}
+
+/**
+ * Extract resources (files, images) from messages
+ */
+function extractResources(messages) {
+  const resources = [];
+
+  for (const message of messages) {
+    if (message.role === "user" && Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block.type === "image") {
+          resources.push({
+            type: "image",
+            data: block.source.type === "base64" ? block.source.data : "",
+            mimeType: block.source.type === "base64" ? block.source.media_type : "",
+            uri: block.source.type === "url" ? block.source.url : undefined,
+          });
+        } else if (block.type === "resource_link") {
+          resources.push({
+            type: "resource",
+            uri: block.uri,
+          });
+        } else if (block.type === "resource" && block.resource?.uri && block.resource?.text) {
+          resources.push({
+            type: "resource",
+            uri: block.resource.uri,
+            text: block.resource.text,
+          });
+        }
+      }
+    }
+  }
+
+  return resources;
+}
+
+/**
+ * Extract user text from messages
+ */
+function extractUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "user") {
+      if (typeof message.content === "string") {
+        return message.content;
+      }
+      if (Array.isArray(message.content)) {
+        return message.content
+          .filter((block) => block.type === "text")
+          .map((block) => block.text)
+          .join("\n");
+      }
+    }
+  }
+  return "";
+}
+
+/**
+ * Extract MCP servers from auth
+ */
+function extractMcpServers(auth) {
+  // Extract any MCP servers from settings
+  // This could be extended to support custom MCP configs
+  return [];
+}
+
+/**
+ * Create an error response
+ */
+function createErrorResponse(error, statusCode = 500) {
+  return new Response(
+    JSON.stringify({
+      type: "error",
+      error: {
+        type: "api_error",
+        message: error.message || String(error),
+      },
+    }),
+    {
+      status: statusCode,
+      headers: { "Content-Type": "application/json" },
+    }
+  );
+}
+
+/**
+ * Log metrics
+ */
+function logMetric(type, data) {
+  try {
+    const METRICS_DIR = process.env.HOME ? join(homedir(), ".opencode-claude-code-wrapper") : "/tmp";
+    const METRICS_FILE = join(METRICS_DIR, "metrics.jsonl");
+    fs.mkdirSync(METRICS_DIR, { recursive: true });
+    const entry = {
+      timestamp: new Date().toISOString(),
+      type,
+      ...data,
+    };
+    fs.appendFileSync(METRICS_FILE, JSON.stringify(entry) + "\n");
+  } catch (e) {
+    console.error("[metrics] Failed to log:", e.message);
+  }
+}
+
           return {
             apiKey: "",
             async fetch(input, init) {

package/lib/acp-client.mjs

@@ -0,0 +1,23 @@
+import { spawn } from "child_process";
+import { randomUUID } from "node:crypto";
+
+/**
+ * Spawn ACP agent (claude-code-acp) binary
+ * @returns {ChildProcess} Spawned ACP process
+ */
+export function spawnAcpAgent() {
+  const child = spawn("claude-code-acp", [], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env },
+  });
+
+  return child;
+}
+
+/**
+ * Create a random message ID
+ * @returns {string} Random ID
+ */
+export function generateId() {
+  return randomUUID();
+}

package/lib/acp-protocol.mjs

@@ -0,0 +1,292 @@
+import { spawnAcpAgent, generateId } from "./acp-client.mjs";
+
+/**
+ * ACP protocol client
+ * Communicates with claude-code-acp via ndjson (newline-delimited JSON)
+ */
+export class AcpClient {
+  constructor() {
+    this.child = null;
+    this.sessionId = null;
+    this.handlers = new Map();
+    this.pendingRequests = new Map();
+  }
+
+  /**
+   * Connect to ACP agent
+   */
+  async connect() {
+    if (this.child) {
+      return;
+    }
+
+    this.child = spawnAcpAgent();
+
+    // Start reading responses
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (data) => {
+      this.handleResponse(data.toString());
+    });
+
+    this.child.stderr.on("data", (data) => {
+      console.error("[ACP] stderr:", data.toString());
+    });
+
+    this.child.on("error", (err) => {
+      console.error("[ACP] Process error:", err);
+    });
+
+    this.child.on("close", (code) => {
+      console.log("[ACP] Process closed with code:", code);
+    });
+
+    // Send initialize request
+    await this.sendRequest({
+      type: "initialize",
+      clientCapabilities: {
+        fs: {
+          readTextFile: true,
+          writeTextFile: true,
+        },
+        terminal: true,
+      },
+    });
+  }
+
+  /**
+   * Create a new session
+   * @param {object} options - Session options
+   */
+  async newSession(options = {}) {
+    const requestId = generateId();
+
+    const request = {
+      type: "newSession",
+      sessionId: null,
+      cwd: process.cwd(),
+      mcpServers: options.mcpServers || [],
+      _meta: options._meta,
+    };
+
+    const response = await this.sendRequest(request, requestId);
+    this.sessionId = response.sessionId;
+    return response;
+  }
+
+  /**
+   * Send a prompt to the session
+   * @param {string} text - User message text
+   * @param {Array} resources - Context resources (files, images)
+   */
+  async prompt(text, resources = []) {
+    if (!this.sessionId) {
+      throw new Error("No active session. Call newSession() first.");
+    }
+
+    const requestId = generateId();
+    const prompt = [];
+
+    // Add text chunks
+    if (text) {
+      prompt.push({ type: "text", text });
+    }
+
+    // Add resource chunks
+    for (const resource of resources) {
+      prompt.push(resource);
+    }
+
+    const request = {
+      type: "prompt",
+      sessionId: this.sessionId,
+      prompt,
+    };
+
+    return this.sendRequest(request, requestId);
+  }
+
+  /**
+   * Cancel current prompt
+   */
+  async cancel() {
+    if (!this.sessionId) {
+      return;
+    }
+
+    const requestId = generateId();
+    await this.sendRequest({
+      type: "cancel",
+      sessionId: this.sessionId,
+    }, requestId);
+  }
+
+  /**
+   * Set session mode
+   * @param {string} mode - Mode to set
+   */
+  async setMode(mode) {
+    if (!this.sessionId) {
+      return;
+    }
+
+    const requestId = generateId();
+    await this.sendRequest({
+      type: "setSessionMode",
+      sessionId: this.sessionId,
+      modeId: mode,
+    }, requestId);
+  }
+
+  /**
+   * Kill the ACP process
+   */
+  kill() {
+    if (this.child) {
+      this.child.kill();
+      this.child = null;
+    }
+    this.sessionId = null;
+  }
+
+  /**
+   * Send a request to ACP agent
+   * @param {object} request - Request object
+   * @param {string} requestId - Request ID for response matching
+   */
+  async sendRequest(request, requestId) {
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject });
+
+      this.child.stdin.write(JSON.stringify({
+        ...request,
+        _requestId: requestId,
+      }) + "\n");
+
+      // Set timeout (2 minutes)
+      setTimeout(() => {
+        const pending = this.pendingRequests.get(requestId);
+        if (pending) {
+          this.pendingRequests.delete(requestId);
+          reject(new Error("Request timeout"));
+        }
+      }, 120000);
+    });
+  }
+
+  /**
+   * Handle responses from ACP agent
+   * @param {string} data - Response data chunk
+   */
+  handleResponse(data) {
+    const lines = data.split("\n").filter((line) => line.trim());
+
+    for (const line of lines) {
+      try {
+        const message = JSON.parse(line);
+        this.handleMessage(message);
+      } catch (e) {
+        console.error("[ACP] Failed to parse response:", line, e);
+      }
+    }
+  }
+
+  /**
+   * Handle individual message from ACP agent
+   * @param {object} message - Parsed message
+   */
+  handleMessage(message) {
+    switch (message.type) {
+      case "initialize_response":
+        this.handleInitializeResponse(message);
+        break;
+
+      case "newSession_response":
+        this.handleNewSessionResponse(message);
+        break;
+
+      case "prompt_response":
+        this.handlePromptResponse(message);
+        break;
+
+      case "sessionUpdate":
+        this.handleSessionUpdate(message);
+        break;
+
+      default:
+        console.warn("[ACP] Unknown message type:", message.type);
+    }
+  }
+
+  /**
+   * Handle initialize response
+   */
+  handleInitializeResponse(message) {
+    const pending = this.pendingRequests.get(message._requestId);
+    if (pending) {
+      this.pendingRequests.delete(message._requestId);
+      pending.resolve(message);
+    }
+  }
+
+  /**
+   * Handle new session response
+   */
+  handleNewSessionResponse(message) {
+    const pending = this.pendingRequests.get(message._requestId);
+    if (pending) {
+      this.pendingRequests.delete(message._requestId);
+      pending.resolve(message);
+    }
+  }
+
+  /**
+   * Handle prompt response (streamed updates)
+   */
+  handlePromptResponse(message) {
+    if (message._requestId) {
+      // Final response
+      const pending = this.pendingRequests.get(message._requestId);
+      if (pending) {
+        this.pendingRequests.delete(message._requestId);
+        pending.resolve(message);
+      }
+    } else {
+      // Session update during streaming
+      this.handleSessionUpdate(message);
+    }
+  }
+
+  /**
+   * Handle session updates (streaming events)
+   */
+  handleSessionUpdate(update) {
+    // Emit events for streaming
+    if (this.handlers.has("update")) {
+      for (const handler of this.handlers.get("update")) {
+        handler(update);
+      }
+    }
+  }
+
+  /**
+   * Register an event handler
+   * @param {string} event - Event type
+   * @param {Function} handler - Event handler
+   */
+  on(event, handler) {
+    if (!this.handlers.has(event)) {
+      this.handlers.set(event, []);
+    }
+    this.handlers.get(event).push(handler);
+  }
+
+  /**
+   * Remove all event handlers for an event type
+   * @param {string} event - Event type
+   */
+  off(event) {
+    this.handlers.delete(event);
+  }
+}
+
+export default AcpClient;

package/lib/acp-transformer.mjs

@@ -0,0 +1,434 @@
+import { generateId } from "./cli-runner.mjs";
+
+/**
+ * Transforms ACP ndjson responses to Anthropic SSE streaming format
+ */
+export class AcpToSSETransformer {
+  constructor() {
+    this.messageId = `msg_${generateId()}`;
+    this.contentBlockIndex = 0;
+    this.hasStarted = false;
+    this.currentBlockStarted = false;
+    this.outputTokens = 0;
+    this.inputTokens = 0;
+  }
+
+  /**
+   * Create an SSE event string
+   * @param {string} eventType - The event type
+   * @param {object} data - The event data
+   * @returns {string} Formatted SSE event
+   */
+  createSSEEvent(eventType, data) {
+    return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+  }
+
+  /**
+   * Transform ACP message to SSE events
+   * @param {object} message - ACP message
+   * @returns {string} SSE events string
+   */
+  transformMessage(message) {
+    const events = [];
+
+    switch (message.type) {
+      case "sessionUpdate":
+        // Handle different session update types
+        const update = message.update;
+        switch (update.sessionUpdate) {
+          case "agent_message_chunk":
+            return this.transformAssistantMessageChunk(update.content);
+          case "tool_call":
+            return this.transformToolCall(update);
+          case "tool_call_update":
+            return this.transformToolCallUpdate(update);
+          case "plan":
+            return this.transformPlan(update.entries);
+          case "current_mode_update":
+            return []; // Mode updates don't need SSE events
+          case "available_commands_update":
+            return []; // Command updates don't need SSE events
+          default:
+            return [];
+        }
+
+      default:
+        console.warn("[Transformer] Unknown ACP message type:", message.type);
+        return [];
+    }
+  }
+
+  /**
+   * Transform assistant message chunk
+   * @param {object} content - Message content
+   * @returns {string} SSE events
+   */
+  transformAssistantMessageChunk(content) {
+    if (!this.hasStarted) {
+      this.hasStarted = true;
+      return [
+        this.createSSEEvent("message_start", {
+          type: "message",
+          message: {
+            id: this.messageId,
+            type: "assistant",
+            content: [],
+            model: "claude-sonnet-4-5-20250929",
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+          },
+        })
+      ];
+    }
+
+    const events = [];
+
+    if (typeof content === "string") {
+      events.push(
+        this.createSSEEvent("content_block_delta", {
+          type: "content_block_delta",
+          index: this.contentBlockIndex,
+          delta: { type: "text_delta", text: content },
+        })
+      );
+      this.outputTokens += Math.ceil(content.length / 4);
+    }
+
+    return events.join("");
+  }
+
+  /**
+   * Transform tool call
+   * @param {object} toolCall - Tool call data
+   * @returns {string} SSE events
+   */
+  transformToolCall(toolCall) {
+    if (!this.hasStarted) {
+      this.hasStarted = true;
+      return [
+        this.createSSEEvent("message_start", {
+          type: "message",
+          message: {
+            id: this.messageId,
+            type: "assistant",
+            content: [],
+            model: "claude-sonnet-4-5-20250929",
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+          },
+        })
+      ];
+    }
+
+    // Close current text block if open
+    if (this.currentBlockStarted) {
+      this.closeCurrentBlock();
+    }
+
+    const events = [];
+
+    // Start tool_use block
+    events.push(
+      this.createSSEEvent("content_block_start", {
+        type: "content_block_start",
+        index: this.contentBlockIndex,
+        content_block: {
+          type: "tool_use",
+          id: toolCall.toolCallId || `toolu_${generateId()}`,
+          name: toolCall.title || "unknown",
+          input: toolCall.rawInput || {},
+        },
+      })
+    );
+
+    // Stream input as input_json_delta
+    const inputStr = JSON.stringify(toolCall.rawInput || {});
+    events.push(
+      this.createSSEEvent("content_block_delta", {
+        type: "content_block_delta",
+        index: this.contentBlockIndex,
+        delta: {
+          type: "input_json_delta",
+          partial_json: inputStr,
+        },
+      })
+    );
+
+    // End tool_use block
+    events.push(
+      this.createSSEEvent("content_block_stop", {
+        type: "content_block_stop",
+        index: this.contentBlockIndex,
+      })
+    );
+
+    this.contentBlockIndex++;
+
+    return events.join("");
+  }
+
+  /**
+   * Transform tool call update (result)
+   * @param {object} update - Tool call update
+   * @returns {string} SSE events
+   */
+  transformToolCallUpdate(update) {
+    if (update.status === "completed") {
+      // Emit result as text block
+      if (!this.hasStarted) {
+        this.hasStarted = true;
+        return [
+          this.createSSEEvent("message_start", {
+            type: "message",
+            message: {
+              id: this.messageId,
+              type: "assistant",
+              content: [],
+              model: "claude-sonnet-4-5-20250929",
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 },
+            },
+          })
+        ];
+      }
+
+      const events = [];
+
+      // Start content block
+      events.push(
+        this.createSSEEvent("content_block_start", {
+          type: "content_block_start",
+          index: this.contentBlockIndex,
+          content_block: { type: "text", text: "" },
+        })
+      );
+
+      // Add content (tool result)
+      const content = this.formatToolResult(update);
+      events.push(
+        this.createSSEEvent("content_block_delta", {
+          type: "content_block_delta",
+          index: this.contentBlockIndex,
+          delta: { type: "text_delta", text: content },
+        })
+      );
+
+      // End content block
+      events.push(
+        this.createSSEEvent("content_block_stop", {
+          type: "content_block_stop",
+          index: this.contentBlockIndex,
+        })
+      );
+
+      this.contentBlockIndex++;
+      return events.join("");
+    } else if (update.status === "failed") {
+      // Show error
+      if (!this.hasStarted) {
+        this.hasStarted = true;
+        return [
+          this.createSSEEvent("message_start", {
+            type: "message",
+            message: {
+              id: this.messageId,
+              type: "assistant",
+              content: [],
+              model: "claude-sonnet-4-5-20250929",
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 },
+            },
+          })
+        ];
+      }
+
+      const events = [];
+
+      // Start content block
+      events.push(
+        this.createSSEEvent("content_block_start", {
+          type: "content_block_start",
+          index: this.contentBlockIndex,
+          content_block: { type: "text", text: "" },
+        })
+      );
+
+      // Add error content
+      const errorContent = this.formatError(update);
+      events.push(
+        this.createSSEEvent("content_block_delta", {
+          type: "content_block_delta",
+          index: this.contentBlockIndex,
+          delta: { type: "text_delta", text: errorContent },
+        })
+      );
+
+      // End content block
+      events.push(
+        this.createSSEEvent("content_block_stop", {
+          type: "content_block_stop",
+          index: this.contentBlockIndex,
+        })
+      );
+
+      this.contentBlockIndex++;
+      return events.join("");
+    }
+
+    return [];
+  }
+
+  /**
+   * Transform plan/TODO entries
+   * @param {Array} entries - Plan entries
+   * @returns {string} SSE events
+   */
+  transformPlan(entries) {
+    if (!this.hasStarted) {
+      this.hasStarted = true;
+      return [
+        this.createSSEEvent("message_start", {
+          type: "message",
+          message: {
+            id: this.messageId,
+            type: "assistant",
+            content: [],
+            model: "claude-sonnet-4-5-20250929",
+            stop_reason: null,
+            stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+          },
+        })
+      ];
+    }
+
+    if (!entries || entries.length === 0) {
+      return [];
+    }
+
+    const events = [];
+    const planText = entries.map((e) => `- [${e.status === "completed" ? "x" : " "}] ${e.content}`).join("\n");
+
+    // Start content block
+    events.push(
+      this.createSSEEvent("content_block_start", {
+        type: "content_block_start",
+        index: this.contentBlockIndex,
+        content_block: { type: "text", text: "" },
+      })
+    );
+
+    // Add plan text
+    events.push(
+      this.createSSEEvent("content_block_delta", {
+        type: "content_block_delta",
+        index: this.contentBlockIndex,
+        delta: { type: "text_delta", text: planText },
+      })
+    );
+
+    // End content block
+    events.push(
+      this.createSSEEvent("content_block_stop", {
+        type: "content_block_stop",
+        index: this.contentBlockIndex,
+      })
+    );
+
+    this.contentBlockIndex++;
+
+    return events.join("");
+  }
+
+  /**
+   * Format tool result for display
+   * @param {object} update - Tool call update
+   * @returns {string} Formatted result
+   */
+  formatToolResult(update) {
+    if (update.content && Array.isArray(update.content)) {
+      // Join multiple content blocks
+      return update.content
+        .map((block) => {
+          if (block.type === "text") {
+            return block.text;
+          }
+          return "";
+        })
+        .filter((text) => text)
+        .join("\n");
+    } else if (typeof update.content === "string") {
+      return update.content;
+    }
+    return "";
+  }
+
+  /**
+   * Format error message
+   * @param {object} update - Tool call update
+   * @returns {string} Formatted error
+   */
+  formatError(update) {
+    if (update.status === "failed" && update.content) {
+      if (typeof update.content === "string") {
+        return `Error: ${update.content}`;
+      }
+      if (Array.isArray(update.content) && update.content.length > 0) {
+        const firstBlock = update.content[0];
+        if (firstBlock.type === "text") {
+          return `Error: ${firstBlock.text}`;
+        }
+      }
+    }
+    return "Error: Tool execution failed";
+  }
+
+  /**
+   * Close current content block
+   */
+  closeCurrentBlock() {
+    this.currentBlockStarted = false;
+  }
+
+  /**
+   * Finalize the stream with closing events
+   * @returns {string} Final SSE events
+   */
+  finalize() {
+    const events = [];
+
+    if (this.hasStarted) {
+      // Close any open content block
+      if (this.currentBlockStarted) {
+        events.push(
+          this.createSSEEvent("content_block_stop", {
+            type: "content_block_stop",
+            index: this.contentBlockIndex,
+          })
+        );
+        this.currentBlockStarted = false;
+      }
+
+      events.push(
+        this.createSSEEvent("message_delta", {
+          type: "message_delta",
+          delta: {
+            stop_reason: "end_turn",
+            stop_sequence: null,
+          },
+          usage: { output_tokens: this.outputTokens },
+        })
+      );
+
+      events.push(
+        this.createSSEEvent("message_stop", { type: "message_stop" })
+      );
+    }
+
+    return events.join("");
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-claude-code-wrapper",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "OpenCode plugin that wraps Claude Code CLI for API-like access",
   "main": "./index.mjs",
   "type": "module",