openAgent

1import { describe, expect } from "bun:test"
2import path from "path"
3import { Cause, Effect, Exit, Fiber, Layer, Option } from "effect"
4import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5import { LayerNode } from "@opencode-ai/core/effect/layer-node"
6import { FSUtil } from "@opencode-ai/core/fs-util"
7import { Global } from "@opencode-ai/core/global"
8import { Config } from "@opencode-ai/core/config"
9import { ConfigToolOutput } from "@opencode-ai/core/config/tool-output"
10import { SessionV2 } from "@opencode-ai/core/session"
11import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
12import { testEffect } from "./lib/effect"
13import { tmpdir } from "./fixture/tmpdir"
14 
15const sessionID = SessionV2.ID.make("ses_tool_output_store")
16 
17const withStore = <A, E, R>(
18  body: (input: { root: string; store: ToolOutputStore.Interface; fs: FSUtil.Interface }) => Effect.Effect<A, E, R>,
19  config?: Config.Info,
20) =>
21  Effect.acquireUseRelease(
22    Effect.promise(() => tmpdir()),
23    (tmp) => {
24      const global = Global.layerWith({ data: tmp.path })
25      const configured = config
26        ? Layer.succeed(
27            Config.Service,
28            Config.Service.of({
29              entries: () => Effect.succeed([new Config.Document({ type: "document", info: config })]),
30            }),
31          )
32        : Layer.empty
33 
34      const store = AppNodeBuilder.build(LayerNode.group([ToolOutputStore.node, FSUtil.node]), [
35        [Global.node, global],
36        [Config.node, configured],
37      ])
38      return Effect.gen(function* () {
39        return yield* body({ root: tmp.path, store: yield* ToolOutputStore.Service, fs: yield* FSUtil.Service })
40      }).pipe(Effect.provide(store))
41    },
42    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
43  )
44 
45const it = testEffect(Layer.empty)
46 
47describe("ToolOutputStore", () => {
48  it.live("bounds the provider-facing text channel with one managed file", () =>
49    withStore(({ store, fs }) =>
50      Effect.gen(function* () {
51        const first = "HEAD-" + "x".repeat(30_000)
52        const second = "y".repeat(30_000) + "-TAIL"
53        const result = yield* store.bound({
54          sessionID,
55          toolCallID: "call-aggregate",
56          output: {
57            structured: { kind: "report" },
58            content: [
59              { type: "text", text: first },
60              { type: "text", text: second },
61            ],
62          },
63        })
64        expect(result.output.structured).toEqual({ kind: "report" })
65        expect(result.outputPaths).toHaveLength(1)
66        expect(yield* fs.readFileString(result.outputPaths[0])).toBe(first + second)
67        if (result.output.content[0]?.type !== "text") throw new Error("expected text preview")
68        expect(Buffer.byteLength(result.output.content[0].text)).toBeLessThanOrEqual(ToolOutputStore.MAX_BYTES)
69      }),
70    ),
71  )
72 
73  it.live("uses bounded text for oversized structured-only output", () =>
74    withStore(({ store, fs }) =>
75      Effect.gen(function* () {
76        const structured = { text: "x".repeat(ToolOutputStore.MAX_BYTES) }
77        const result = yield* store.bound({ sessionID, toolCallID: "call-json", output: { structured, content: [] } })
78        expect(result.output.structured).toEqual(structured)
79        expect(result.outputPaths).toHaveLength(1)
80        expect(JSON.parse(yield* fs.readFileString(result.outputPaths[0]))).toEqual(structured)
81        expect(result.output.content).toHaveLength(1)
82      }),
83    ),
84  )
85 
86  it.live("preserves native media and structured metadata without applying a settlement media limit", () =>
87    withStore(({ store }) =>
88      Effect.gen(function* () {
89        const data = "a".repeat(6 * 1024 * 1024)
90        const result = yield* store.bound({
91          sessionID,
92          toolCallID: "call-file",
93          output: {
94            structured: { caption: "pixel" },
95            content: [{ type: "file", uri: `data:image/png;base64,${data}`, mime: "image/png", name: "pixel.png" }],
96          },
97        })
98        expect(result.outputPaths).toEqual([])
99        expect(result.output.structured).toEqual({ caption: "pixel" })
100        expect(result.output.content).toHaveLength(1)
101        expect(result.output.content[0]).toEqual({
102          type: "file",
103          uri: `data:image/png;base64,${data}`,
104          mime: "image/png",
105          name: "pixel.png",
106        })
107      }),
108    ),
109  )
110 
111  it.live("preserves structured metadata and native media when bounding text", () =>
112    withStore(({ store, fs }) =>
113      Effect.gen(function* () {
114        const text = "x".repeat(ToolOutputStore.MAX_BYTES + 1)
115        const media = {
116          type: "file" as const,
117          uri: "data:image/png;base64,aGVsbG8=",
118          mime: "image/png",
119          name: "pixel.png",
120        }
121        const result = yield* store.bound({
122          sessionID,
123          toolCallID: "call-text-and-media",
124          output: { structured: { caption: "pixel" }, content: [{ type: "text", text }, media] },
125        })
126 
127        expect(result.output.structured).toEqual({ caption: "pixel" })
128        expect(result.output.content[1]).toEqual(media)
129        expect(yield* fs.readFileString(result.outputPaths[0])).toBe(text)
130      }),
131    ),
132  )
133 
134  it.live("does not double-count structured data duplicated in projected text", () =>
135    withStore(({ store }) =>
136      Effect.gen(function* () {
137        const text = "x".repeat(30_000)
138        const output = { structured: { output: text }, content: [{ type: "text" as const, text }] }
139        expect(yield* store.bound({ sessionID, toolCallID: "call-duplicated", output })).toEqual({
140          output,
141          outputPaths: [],
142        })
143      }),
144    ),
145  )
146 
147  it.live("fails oversized settlement when complete retention cannot be written", () =>
148    withStore(({ root, store, fs }) =>
149      Effect.gen(function* () {
150        yield* fs.writeFileString(path.join(root, "tool-output"), "not a directory")
151        const exit = yield* store
152          .bound({
153            sessionID,
154            toolCallID: "call-lossy",
155            output: { structured: {}, content: [{ type: "text", text: "x".repeat(ToolOutputStore.MAX_BYTES + 1) }] },
156          })
157          .pipe(Effect.exit)
158        expect(Exit.isFailure(exit)).toBe(true)
159        if (Exit.isFailure(exit))
160          expect(Option.getOrUndefined(Cause.findErrorOption(exit.cause))?._tag).toBe("ToolOutputStore.StorageError")
161      }),
162    ),
163  )
164 
165  it.live("does not encode ignored structured metadata when projected content exists", () =>
166    withStore(({ store }) =>
167      Effect.gen(function* () {
168        const output = { structured: { value: 1n }, content: [{ type: "text" as const, text: "readable text" }] }
169        expect(yield* store.bound({ sessionID, toolCallID: "call-unencodable", output })).toEqual({
170          output,
171          outputPaths: [],
172        })
173      }),
174    ),
175  )
176 
177  it.live("preserves interruption while retaining complete output", () =>
178    Effect.gen(function* () {
179      const root = yield* Effect.promise(() => tmpdir())
180      const blockedFilesystem = Layer.effect(
181        FSUtil.Service,
182        Effect.gen(function* () {
183          const fs = yield* FSUtil.Service
184          return FSUtil.Service.of({
185            ...fs,
186            ensureDir: () => Effect.void,
187            writeFileString: () => Effect.never,
188          })
189        }),
190      ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
191      const store = AppNodeBuilder.build(ToolOutputStore.nodeWithoutConfig, [
192        [Global.node, Global.layerWith({ data: root.path })],
193        [FSUtil.node, blockedFilesystem],
194      ])
195      const exit = yield* Effect.gen(function* () {
196        const service = yield* ToolOutputStore.Service
197        const fiber = yield* service
198          .bound({
199            sessionID,
200            toolCallID: "call-interrupted",
201            output: { structured: {}, content: [{ type: "text", text: "x".repeat(ToolOutputStore.MAX_BYTES + 1) }] },
202          })
203          .pipe(Effect.forkChild)
204        yield* Fiber.interrupt(fiber)
205        return yield* Fiber.await(fiber)
206      }).pipe(Effect.provide(store))
207      expect(Exit.isFailure(exit) && Cause.hasInterrupts(exit.cause)).toBe(true)
208      yield* Effect.promise(() => root[Symbol.asyncDispose]())
209    }),
210  )
211 
212  it.live("honors configured limits", () =>
213    withStore(
214      ({ store }) =>
215        Effect.gen(function* () {
216          expect(yield* store.limits()).toEqual({ maxLines: 2, maxBytes: 1_000 })
217          const result = yield* store.bound({
218            sessionID,
219            toolCallID: "call-config",
220            output: { structured: {}, content: [{ type: "text", text: "one\ntwo\nthree" }] },
221          })
222          expect(result.outputPaths).toHaveLength(1)
223        }),
224      new Config.Info({ tool_output: new ConfigToolOutput.Info({ max_lines: 2, max_bytes: 1_000 }) }),
225    ),
226  )
227 
228  it.live("cleans expired managed files and preserves unrelated files", () =>
229    withStore(({ root, store, fs }) =>
230      Effect.gen(function* () {
231        const old = path.join(root, "tool-output", "tool_old")
232        const recent = path.join(root, "tool-output", "tool_recent")
233        const unrelated = path.join(root, "tool-output", "keep.txt")
234        yield* fs.ensureDir(path.join(root, "tool-output"))
235        yield* fs.writeFileString(old, "old")
236        yield* fs.writeFileString(recent, "recent")
237        yield* fs.writeFileString(unrelated, "keep")
238        const expired = new Date(Date.now() - 8 * 24 * 60 * 60 * 1_000)
239        yield* fs.utimes(old, expired, expired)
240        yield* store.cleanup()
241        expect(yield* fs.exists(old)).toBe(false)
242        expect(yield* fs.exists(recent)).toBe(true)
243        expect(yield* fs.exists(unrelated)).toBe(true)
244      }),
245    ),
246  )
247})
248