fix(acp): emit tool_call_update with content/title and raw I/O

Author: validatedev

packages/opencode/src/acp/agent.ts

@@ -51,6 +51,7 @@ import { LoadAPIKeyError } from "ai"
 import type { AssistantMessage, Event, OpencodeClient, SessionMessageResponse, ToolPart } from "@opencode-ai/sdk/v2"
 import { applyPatch } from "diff"
 import { InstallationVersion } from "@/installation/version"
+import { toolCallFromPart, toolResultFromPart } from "./tool-format"
 
 type ModeOption = { id: string; name: string; description?: string }
 type ModelOption = { modelId: string; name: string }
@@ -198,16 +199,17 @@ export class Agent implements ACPAgent {
           .then(async () => {
             const directory = session.cwd
 
+            const permissionInfo = toolCallFromPart(permission.permission, permission.metadata ?? {})
             const res = await this.connection
               .requestPermission({
                 sessionId: permission.sessionID,
                 toolCall: {
                   toolCallId: permission.tool?.callID ?? permission.id,
                   status: "pending",
-                  title: permission.permission,
-                  rawInput: permission.metadata,
-                  kind: toToolKind(permission.permission),
-                  locations: toLocations(permission.permission, permission.metadata),
+                  title: permissionInfo.title,
+                  rawInput: permissionInfo.rawInput,
+                  kind: permissionInfo.kind,
+                  locations: permissionInfo.locations,
                 },
                 options: this.permissionOptions,
               })
@@ -279,13 +281,14 @@ export class Agent implements ACPAgent {
 
         if (part.type === "tool") {
           await this.toolStart(sessionId, part)
+          const info = toolCallFromPart(part.tool, part.state.input)
 
           switch (part.state.status) {
             case "pending":
               this.bashSnapshots.delete(part.callID)
               return
 
-            case "running":
+            case "running": {
               const output = this.bashOutput(part)
               const content: ToolCallContent[] = []
               if (output) {
@@ -299,10 +302,10 @@ export class Agent implements ACPAgent {
                           sessionUpdate: "tool_call_update",
                           toolCallId: part.callID,
                           status: "in_progress",
-                          kind: toToolKind(part.tool),
-                          title: part.tool,
-                          locations: toLocations(part.tool, part.state.input),
-                          rawInput: part.state.input,
+                          kind: info.kind,
+                          title: info.title,
+                          locations: info.locations,
+                          rawInput: info.rawInput,
                         },
                       })
                       .catch((error) => {
@@ -327,49 +330,23 @@ export class Agent implements ACPAgent {
                     sessionUpdate: "tool_call_update",
                     toolCallId: part.callID,
                     status: "in_progress",
-                    kind: toToolKind(part.tool),
-                    title: part.tool,
-                    locations: toLocations(part.tool, part.state.input),
-                    rawInput: part.state.input,
+                    kind: info.kind,
+                    title: info.title,
+                    locations: info.locations,
+                    rawInput: info.rawInput,
                     ...(content.length > 0 && { content }),
                   },
                 })
                 .catch((error) => {
                   log.error("failed to send tool in_progress to ACP", { error })
                 })
               return
+            }
 
             case "completed": {
               this.toolStarts.delete(part.callID)
               this.bashSnapshots.delete(part.callID)
-              const kind = toToolKind(part.tool)
-              const content: ToolCallContent[] = [
-                {
-                  type: "content",
-                  content: {
-                    type: "text",
-                    text: part.state.output,
-                  },
-                },
-              ]
-
-              if (kind === "edit") {
-                const input = part.state.input
-                const filePath = typeof input["filePath"] === "string" ? input["filePath"] : ""
-                const oldText = typeof input["oldString"] === "string" ? input["oldString"] : ""
-                const newText =
-                  typeof input["newString"] === "string"
-                    ? input["newString"]
-                    : typeof input["content"] === "string"
-                      ? input["content"]
-                      : ""
-                content.push({
-                  type: "diff",
-                  path: filePath,
-                  oldText,
-                  newText,
-                })
-              }
+              const result = toolResultFromPart(part.tool, part.state.input, part.state.output, false)
 
               if (part.tool === "todowrite") {
                 const parsedTodos = z.array(Todo.Info).safeParse(JSON.parse(part.state.output))
@@ -405,53 +382,38 @@ export class Agent implements ACPAgent {
                     sessionUpdate: "tool_call_update",
                     toolCallId: part.callID,
                     status: "completed",
-                    kind,
-                    content,
-                    title: part.state.title,
-                    rawInput: part.state.input,
-                    rawOutput: {
-                      output: part.state.output,
-                      metadata: part.state.metadata,
-                    },
+                    content: result.content,
+                    rawOutput: result.rawOutput,
+                    ...(result.title ? { title: result.title } : {}),
                   },
                 })
                 .catch((error) => {
                   log.error("failed to send tool completed to ACP", { error })
                 })
               return
             }
-            case "error":
+            case "error": {
               this.toolStarts.delete(part.callID)
               this.bashSnapshots.delete(part.callID)
+              const result = toolResultFromPart(part.tool, part.state.input, part.state.error, true)
+
               await this.connection
                 .sessionUpdate({
                   sessionId,
                   update: {
                     sessionUpdate: "tool_call_update",
                     toolCallId: part.callID,
                     status: "failed",
-                    kind: toToolKind(part.tool),
-                    title: part.tool,
-                    rawInput: part.state.input,
-                    content: [
-                      {
-                        type: "content",
-                        content: {
-                          type: "text",
-                          text: part.state.error,
-                        },
-                      },
-                    ],
-                    rawOutput: {
-                      error: part.state.error,
-                      metadata: part.state.metadata,
-                    },
+                    content: result.content,
+                    rawOutput: result.rawOutput,
+                    ...(result.title ? { title: result.title } : {}),
                   },
                 })
                 .catch((error) => {
                   log.error("failed to send tool error to ACP", { error })
                 })
               return
+            }
           }
         }