fix(acp): preserve file attachment metadata during session replay

- Filter synthetic text parts during ACP replay
- Replay file parts as ACP content blocks (images, binary resources, text resources)
- Add audio content support in prompts
- Convert resources to file parts with data URLs preserving metadata
- Whitelist binary content for LLM (image/audio/video/pdf as file parts, everything else as text)

Author: liorshk

packages/opencode/src/acp/agent.ts

@@ -612,7 +612,7 @@ export namespace ACP {
           }
         }
         if (part.type === "text") {
-          if (part.text) {
+          if (part.text && !part.synthetic) {
             await this.connection
               .sessionUpdate({
                 sessionId,
@@ -677,15 +677,33 @@ export namespace ACP {
             continue
           }
 
-          // Skip binary non-image files - ACP resource blocks only support text content
-          const isTextBased =
-            mime.startsWith("text/") ||
-            mime === "application/json" ||
-            mime === "application/xml" ||
-            mime === "application/javascript" ||
-            mime === "application/typescript" ||
-            mime === "application/x-directory"
-          if (!isTextBased) continue
+          const isBinaryContent =
+            mime.startsWith("audio/") ||
+            mime.startsWith("video/") ||
+            mime === "application/pdf" ||
+            mime === "application/octet-stream"
+
+          if (isBinaryContent) {
+            await this.connection
+              .sessionUpdate({
+                sessionId,
+                update: {
+                  sessionUpdate: "user_message_chunk",
+                  content: {
+                    type: "resource",
+                    resource: {
+                      uri: `file://${filename}`,
+                      mimeType: mime,
+                      blob: base64Data,
+                    },
+                  },
+                },
+              })
+              .catch((err) => {
+                log.error("failed to send binary resource to ACP", { error: err })
+              })
+            continue
+          }
 
           const text = Buffer.from(base64Data, "base64").toString("utf-8")
           await this.connection
@@ -908,6 +926,18 @@ export namespace ACP {
             break
           }
 
+          case "audio":
+            if (part.data) {
+              const ext = part.mimeType.split("/")[1] || "audio"
+              parts.push({
+                type: "file",
+                url: `data:${part.mimeType};base64,${part.data}`,
+                filename: `audio.${ext}`,
+                mime: part.mimeType,
+              })
+            }
+            break
+
           case "resource_link":
             const parsed = parseUri(part.uri)
             parts.push(parsed)
@@ -919,7 +949,7 @@ export namespace ACP {
             const filename = resource.uri?.replace(/^file:\/\//, "").split("/").pop() || "file"
             const mime = resource.mimeType || "text/plain"
 
-            if ("text" in resource) {
+            if ("text" in resource && resource.text) {
               const base64 = Buffer.from(resource.text, "utf-8").toString("base64")
               parts.push({
                 type: "file",
@@ -929,14 +959,21 @@ export namespace ACP {
               })
               break
             }
-            if ("blob" in resource) {
+            if ("blob" in resource && resource.blob) {
               parts.push({
                 type: "file",
                 url: `data:${mime};base64,${resource.blob}`,
                 filename,
                 mime,
               })
+              break
             }
+            parts.push({
+              type: "file",
+              url: resource.uri || `file://${filename}`,
+              filename,
+              mime,
+            })
             break
           }
 

packages/opencode/src/session/message-v2.ts

@@ -439,39 +439,35 @@ export namespace MessageV2 {
               text: part.text,
             })
           if (part.type === "file") {
-            // Skip directory markers
             if (part.mime === "application/x-directory") continue
 
-            const isTextBased =
-              part.mime.startsWith("text/") ||
-              part.mime === "application/json" ||
-              part.mime === "application/xml" ||
-              part.mime === "application/javascript" ||
-              part.mime === "application/typescript"
-
-            if (isTextBased) {
-              // Decode text-based files and send as text with filename header
-              const url = part.url
-              if (url.startsWith("data:")) {
-                const match = url.match(/^data:[^;]+;base64,(.*)$/)
-                if (match) {
-                  const text = Buffer.from(match[1], "base64").toString("utf-8")
-                  userMessage.parts.push({
-                    type: "text",
-                    text: `[File: ${part.filename || "file"}]\n${text}`,
-                  })
-                }
-              }
+            const isBinaryContent =
+              part.mime.startsWith("image/") ||
+              part.mime.startsWith("audio/") ||
+              part.mime.startsWith("video/") ||
+              part.mime === "application/pdf"
+
+            if (isBinaryContent) {
+              userMessage.parts.push({
+                type: "file",
+                url: part.url,
+                mediaType: part.mime,
+                filename: part.filename,
+              })
               continue
             }
 
-            // Send binary files (images, etc.) as file parts
-            userMessage.parts.push({
-              type: "file",
-              url: part.url,
-              mediaType: part.mime,
-              filename: part.filename,
-            })
+            const url = part.url
+            if (url.startsWith("data:")) {
+              const match = url.match(/^data:[^;]+;base64,(.*)$/)
+              if (match) {
+                const text = Buffer.from(match[1], "base64").toString("utf-8")
+                userMessage.parts.push({
+                  type: "text",
+                  text: `[File: ${part.filename || "file"}]\n${text}`,
+                })
+              }
+            }
           }
 
           if (part.type === "compaction") {