openAgent

1import { describe, expect, test } from "bun:test"
2import type { ContentBlock } from "@agentclientprotocol/sdk"
3import { pathToFileURL } from "node:url"
4import { contentBlockToParts, partsToContentChunks, promptContentToParts } from "../../src/acp/content"
5 
6describe("acp content conversion", () => {
7  test("plain text block becomes a text part", () => {
8    expect(contentBlockToParts({ type: "text", text: "hello" })).toEqual([{ type: "text", text: "hello" }])
9  })
10 
11  test("assistant-only text audience becomes synthetic", () => {
12    expect(
13      contentBlockToParts({
14        type: "text",
15        text: "internal",
16        annotations: { audience: ["assistant"] },
17      }),
18    ).toEqual([{ type: "text", text: "internal", synthetic: true }])
19  })
20 
21  test("user-only text audience becomes ignored", () => {
22    expect(
23      contentBlockToParts({
24        type: "text",
25        text: "visible to user",
26        annotations: { audience: ["user"] },
27      }),
28    ).toEqual([{ type: "text", text: "visible to user", ignored: true }])
29  })
30 
31  test("image block with base64 data becomes a data URL file part", () => {
32    expect(
33      contentBlockToParts({
34        type: "image",
35        data: "AAAA",
36        mimeType: "image/png",
37        uri: "file:///tmp/screenshot.png",
38      }),
39    ).toEqual([
40      {
41        type: "file",
42        url: "data:image/png;base64,AAAA",
43        filename: "screenshot.png",
44        mime: "image/png",
45      },
46    ])
47  })
48 
49  test("image block with http URI becomes a file part", () => {
50    expect(
51      contentBlockToParts({
52        type: "image",
53        data: "",
54        mimeType: "image/jpeg",
55        uri: "http://example.com/assets/photo.jpg",
56      }),
57    ).toEqual([
58      {
59        type: "file",
60        url: "http://example.com/assets/photo.jpg",
61        filename: "photo.jpg",
62        mime: "image/jpeg",
63      },
64    ])
65  })
66 
67  test("resource_link file URL becomes a file part with name and fallback mime", () => {
68    expect(
69      contentBlockToParts({
70        type: "resource_link",
71        uri: "file:///tmp/notes.txt",
72        name: "client-notes.txt",
73      }),
74    ).toEqual([
75      {
76        type: "file",
77        url: "file:///tmp/notes.txt",
78        filename: "client-notes.txt",
79        mime: "text/plain",
80      },
81    ])
82  })
83 
84  test("resource_link zed path becomes a file URL part", () => {
85    expect(
86      contentBlockToParts({
87        type: "resource_link",
88        uri: "zed://workspace?path=/tmp/project/src/app.ts",
89        name: "app.ts",
90        mimeType: "text/typescript",
91      }),
92    ).toEqual([
93      {
94        type: "file",
95        url: pathToFileURL("/tmp/project/src/app.ts").href,
96        filename: "app.ts",
97        mime: "text/typescript",
98      },
99    ])
100  })
101 
102  test("resource with text becomes a sourced text part", () => {
103    const result = contentBlockToParts({
104      type: "resource",
105      resource: {
106        uri: "file:///tmp/context.txt#L12-L14",
107        mimeType: "text/plain",
108        text: "context",
109      },
110    })
111    expect(result).toHaveLength(1)
112    expect(result[0]?.type).toBe("text")
113    if (result[0]?.type === "text") {
114      expect(result[0].text.endsWith("\ncontext")).toBe(true)
115      expect(result[0].text.includes("context.txt")).toBe(true)
116      expect(result[0].text.includes("12")).toBe(true)
117    }
118  })
119 
120  test("resource with text uses URI fallback for non-file resources", () => {
121    expect(
122      contentBlockToParts({
123        type: "resource",
124        resource: {
125          uri: "mcp://server/context",
126          text: "context",
127        },
128      }),
129    ).toEqual([{ type: "text", text: "[mcp://server/context]\ncontext" }])
130  })
131 
132  test("resource with text includes file path", () => {
133    const result = contentBlockToParts({
134      type: "resource",
135      resource: {
136        uri: "file:///tmp/context.txt",
137        mimeType: "text/plain",
138        text: "context",
139      },
140    })
141    expect(result).toHaveLength(1)
142    expect(result[0]?.type).toBe("text")
143    if (result[0]?.type === "text") {
144      expect(result[0].text.endsWith("\ncontext")).toBe(true)
145      expect(result[0].text.includes("context.txt")).toBe(true)
146    }
147  })
148 
149  test("resource with blob and mimeType becomes a data URL file part", () => {
150    expect(
151      contentBlockToParts({
152        type: "resource",
153        resource: {
154          uri: "file:///tmp/report.pdf",
155          mimeType: "application/pdf",
156          blob: "JVBERg==",
157        },
158      }),
159    ).toEqual([
160      {
161        type: "file",
162        url: "data:application/pdf;base64,JVBERg==",
163        filename: "report.pdf",
164        mime: "application/pdf",
165      },
166    ])
167  })
168 
169  test("data URL resource is preserved as a file part", () => {
170    expect(
171      contentBlockToParts({
172        type: "resource",
173        resource: {
174          uri: "data:text/plain;base64,aGVsbG8=",
175          mimeType: "text/plain",
176          blob: "ignored",
177        },
178      }),
179    ).toEqual([
180      {
181        type: "file",
182        url: "data:text/plain;base64,aGVsbG8=",
183        filename: "file",
184        mime: "text/plain",
185      },
186    ])
187  })
188 
189  test("unsupported blocks are ignored", () => {
190    expect(promptContentToParts([{ type: "audio", data: "AAAA", mimeType: "audio/wav" }])).toEqual([])
191    expect(promptContentToParts([{ type: "unknown", text: "skip" } as unknown as ContentBlock])).toEqual([])
192  })
193})
194 
195describe("acp replay conversion", () => {
196  test("replays text audience annotations", () => {
197    expect(partsToContentChunks([{ type: "text", text: "cached", synthetic: true }])).toEqual([
198      {
199        content: {
200          type: "text",
201          text: "cached",
202          annotations: { audience: ["assistant"] },
203        },
204      },
205    ])
206  })
207 
208  test("replays file and data URL parts as ACP content", () => {
209    expect(
210      partsToContentChunks([
211        { type: "file", url: "file:///tmp/readme.md", filename: "readme.md", mime: "text/markdown" },
212        { type: "file", url: "data:text/plain;base64,aGVsbG8=", filename: "note.txt", mime: "text/plain" },
213      ]),
214    ).toEqual([
215      {
216        content: {
217          type: "resource_link",
218          uri: "file:///tmp/readme.md",
219          name: "readme.md",
220          mimeType: "text/markdown",
221        },
222      },
223      {
224        content: {
225          type: "resource",
226          resource: {
227            uri: pathToFileURL("note.txt").href,
228            mimeType: "text/plain",
229            text: "hello",
230          },
231        },
232      },
233    ])
234  })
235})
236