artificial-code 1.17.13

package/test/tool/tool-define.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect } from "bun:test"
+import { LayerNode } from "@ac/core/effect/layer-node"
+import { Cause, Effect, Exit, Schema } from "effect"
+import { Agent } from "../../src/agent/agent"
+import { MessageID, SessionID } from "../../src/session/schema"
+import { Tool } from "@/tool/tool"
+import { Truncate } from "@/tool/truncate"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(LayerNode.compile(LayerNode.group([Truncate.node, Agent.node])))
+
+const params = Schema.Struct({ input: Schema.String })
+
+function makeCtx(): Tool.Context {
+  return {
+    sessionID: SessionID.descending(),
+    messageID: MessageID.ascending(),
+    agent: "build",
+    abort: new AbortController().signal,
+    messages: [],
+    metadata() {
+      return Effect.void
+    },
+    ask() {
+      return Effect.void
+    },
+  }
+}
+
+function makeTool(id: string, executeFn?: () => void) {
+  return {
+    description: "test tool",
+    parameters: params,
+    execute() {
+      executeFn?.()
+      return Effect.succeed({ title: "test", output: "ok", metadata: {} })
+    },
+  }
+}
+
+describe("Tool.define", () => {
+  it.effect("object-defined tool does not mutate the original init object", () =>
+    Effect.gen(function* () {
+      const original = makeTool("test")
+      const originalExecute = original.execute
+
+      const info = yield* Tool.define("test-tool", Effect.succeed(original))
+
+      yield* info.init()
+      yield* info.init()
+      yield* info.init()
+
+      expect(original.execute).toBe(originalExecute)
+    }),
+  )
+
+  it.effect("effect-defined tool returns fresh objects and is unaffected", () =>
+    Effect.gen(function* () {
+      const info = yield* Tool.define(
+        "test-fn-tool",
+        Effect.succeed(() => Effect.succeed(makeTool("test"))),
+      )
+
+      const first = yield* info.init()
+      const second = yield* info.init()
+
+      expect(first).not.toBe(second)
+    }),
+  )
+
+  it.effect("object-defined tool returns distinct objects per init() call", () =>
+    Effect.gen(function* () {
+      const info = yield* Tool.define("test-copy", Effect.succeed(makeTool("test")))
+
+      const first = yield* info.init()
+      const second = yield* info.init()
+
+      expect(first).not.toBe(second)
+    }),
+  )
+
+  it.effect("execute receives decoded parameters", () =>
+    Effect.gen(function* () {
+      const parameters = Schema.Struct({
+        count: Schema.NumberFromString.pipe(Schema.optional, Schema.withDecodingDefaultType(Effect.succeed(5))),
+      })
+      const calls: Array<Schema.Schema.Type<typeof parameters>> = []
+      const info = yield* Tool.define(
+        "test-decoded",
+        Effect.succeed({
+          description: "test tool",
+          parameters,
+          execute(args: Schema.Schema.Type<typeof parameters>) {
+            calls.push(args)
+            return Effect.succeed({ title: "test", output: "ok", metadata: { truncated: false } })
+          },
+        }),
+      )
+      const ctx = makeCtx()
+      const tool = yield* info.init()
+      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
+
+      yield* execute({}, ctx)
+      yield* execute({ count: "7" }, ctx)
+
+      expect(calls).toEqual([{ count: 5 }, { count: 7 }])
+    }),
+  )
+
+  // Regression for #28438: the wrap is the canonical "untyped → typed" boundary.
+  // When the LLM emits a tool call with a payload that fails the parameter
+  // schema, the wrap must surface a typed `Tool.InvalidArgumentsError` whose
+  // `.message` is the actionable prose the AI SDK feeds back to the model.
+  it.effect("invalid args surface as Tool.InvalidArgumentsError with friendly message and JSON path", () =>
+    Effect.gen(function* () {
+      const parameters = Schema.Struct({
+        questions: Schema.Array(
+          Schema.Struct({
+            question: Schema.String,
+            options: Schema.Array(Schema.String),
+          }),
+        ),
+      })
+      const info = yield* Tool.define(
+        "qtest",
+        Effect.succeed({
+          description: "test tool",
+          parameters,
+          execute() {
+            return Effect.succeed({ title: "ok", output: "ok", metadata: { truncated: false } })
+          },
+        }),
+      )
+      const tool = yield* info.init()
+      const execute = tool.execute as unknown as (args: unknown, ctx: Tool.Context) => ReturnType<typeof tool.execute>
+
+      // Missing required `question` field on the first questions[] entry.
+      const exit = yield* execute({ questions: [{ options: ["a"] }] }, makeCtx()).pipe(Effect.exit)
+      expect(Exit.isFailure(exit)).toBe(true)
+      if (!Exit.isFailure(exit)) return
+
+      // The wrap ends with Effect.orDie, so the failure lives in the cause as a
+      // defect. Recover the typed instance from there.
+      const die = exit.cause.reasons.find(Cause.isDieReason)
+      const error = die?.defect
+      expect(error).toBeInstanceOf(Tool.InvalidArgumentsError)
+      const args = error as Tool.InvalidArgumentsError
+      expect(args.tool).toBe("qtest")
+      expect(args.message).toContain("qtest tool was called with invalid arguments")
+      expect(args.message).toContain("Please rewrite the input")
+      expect(args.message).toContain(`["questions"][0]["question"]`)
+    }),
+  )
+})

package/test/tool/truncation.test.ts

@@ -0,0 +1,264 @@
+import { describe, test, expect } from "bun:test"
+import { ConfigV1 } from "@ac/core/v1/config/config"
+import { LayerNode } from "@ac/core/effect/layer-node"
+import { filesystem } from "@ac/core/effect/app-node-platform"
+import { FSUtil } from "@ac/core/fs-util"
+import { Effect, FileSystem } from "effect"
+import { Truncate } from "@/tool/truncate"
+import { Config } from "@/config/config"
+import { Identifier } from "../../src/id/id"
+import { Process } from "@/util/process"
+import path from "path"
+import { testEffect } from "../lib/effect"
+import { writeFileStringScoped } from "../lib/filesystem"
+import { TestConfig } from "../fixture/config"
+
+const FIXTURES_DIR = path.join(import.meta.dir, "fixtures")
+const ROOT = path.resolve(import.meta.dir, "..", "..")
+
+const it = testEffect(LayerNode.compile(LayerNode.group([Truncate.node, FSUtil.node, filesystem])))
+
+const configuredLayer = (cfg: ConfigV1.Info) =>
+  LayerNode.compile(LayerNode.group([Truncate.node, FSUtil.node, filesystem, Config.node]), [
+    [Config.node, TestConfig.layer({ get: () => Effect.succeed(cfg) })],
+  ])
+const configuredIt = (cfg: ConfigV1.Info) => testEffect(configuredLayer(cfg))
+
+describe("Truncate", () => {
+  describe("output", () => {
+    it.live("truncates large json file by bytes", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const fsys = yield* FSUtil.Service
+        const content = yield* fsys.readFileString(path.join(FIXTURES_DIR, "models-api.json"))
+        const result = yield* svc.output(content)
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("truncated...")
+        if (result.truncated) expect(result.outputPath).toBeDefined()
+      }),
+    )
+
+    it.live("returns content unchanged when under limits", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const content = "line1\nline2\nline3"
+        const result = yield* svc.output(content)
+
+        expect(result.truncated).toBe(false)
+        expect(result.content).toBe(content)
+      }),
+    )
+
+    it.live("truncates by line count", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+        const result = yield* svc.output(lines, { maxLines: 10 })
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("...90 lines truncated...")
+      }),
+    )
+
+    it.live("truncates by byte count", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const content = "a".repeat(1000)
+        const result = yield* svc.output(content, { maxBytes: 100 })
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("truncated...")
+      }),
+    )
+
+    it.live("truncates from head by default", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+        const result = yield* svc.output(lines, { maxLines: 3 })
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("line0")
+        expect(result.content).toContain("line1")
+        expect(result.content).toContain("line2")
+        expect(result.content).not.toContain("line9")
+      }),
+    )
+
+    it.live("truncates from tail when direction is tail", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 10 }, (_, i) => `line${i}`).join("\n")
+        const result = yield* svc.output(lines, { maxLines: 3, direction: "tail" })
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("line7")
+        expect(result.content).toContain("line8")
+        expect(result.content).toContain("line9")
+        expect(result.content).not.toContain("line0")
+      }),
+    )
+
+    test("uses default MAX_LINES and MAX_BYTES", () => {
+      expect(Truncate.MAX_LINES).toBe(2000)
+      expect(Truncate.MAX_BYTES).toBe(50 * 1024)
+    })
+
+    it.live("limits() falls back to MAX_LINES/MAX_BYTES when Config is not provided", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const resolved = yield* svc.limits()
+        expect(resolved.maxLines).toBe(Truncate.MAX_LINES)
+        expect(resolved.maxBytes).toBe(Truncate.MAX_BYTES)
+      }),
+    )
+
+    describe("with tool_output config", () => {
+      const limitsIt = configuredIt({ tool_output: { max_lines: 123, max_bytes: 456 } })
+      limitsIt.live("limits() reflects config overrides", () =>
+        Effect.gen(function* () {
+          const resolved = yield* (yield* Truncate.Service).limits()
+          expect(resolved.maxLines).toBe(123)
+          expect(resolved.maxBytes).toBe(456)
+        }),
+      )
+
+      // Huge byte budget isolates line truncation. 100 lines against max_lines: 10
+      // proves the configured line limit is what `output()` enforces.
+      const lineIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 1024 * 1024 } })
+      lineIt.live("output() truncates to configured max_lines", () =>
+        Effect.gen(function* () {
+          const content = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+          const result = yield* (yield* Truncate.Service).output(content)
+          expect(result.truncated).toBe(true)
+          expect(result.content).toContain("...90 lines truncated...")
+        }),
+      )
+
+      // Huge line budget isolates byte truncation.
+      const byteIt = configuredIt({ tool_output: { max_lines: 1_000_000, max_bytes: 100 } })
+      byteIt.live("output() truncates to configured max_bytes", () =>
+        Effect.gen(function* () {
+          const content = "a".repeat(1000)
+          const result = yield* (yield* Truncate.Service).output(content)
+          expect(result.truncated).toBe(true)
+          expect(result.content).toContain("bytes truncated...")
+        }),
+      )
+
+      const overrideIt = configuredIt({ tool_output: { max_lines: 10, max_bytes: 100 } })
+      overrideIt.live("per-call options still override config", () =>
+        Effect.gen(function* () {
+          const content = Array.from({ length: 50 }, (_, i) => `line${i}`).join("\n")
+          const result = yield* (yield* Truncate.Service).output(content, {
+            maxLines: 1000,
+            maxBytes: 1024 * 1024,
+          })
+          expect(result.truncated).toBe(false)
+        }),
+      )
+    })
+
+    it.live("large single-line file truncates with byte message", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const fsys = yield* FSUtil.Service
+        const content = yield* fsys.readFileString(path.join(FIXTURES_DIR, "models-api.json"))
+        const result = yield* svc.output(content)
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("bytes truncated...")
+        expect(Buffer.byteLength(content, "utf-8")).toBeGreaterThan(Truncate.MAX_BYTES)
+      }),
+    )
+
+    it.live("writes full output to file when truncated", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+        const result = yield* svc.output(lines, { maxLines: 10 })
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("The tool call succeeded but the output was truncated")
+        expect(result.content).toContain("Grep")
+        if (!result.truncated) throw new Error("expected truncated")
+        expect(result.outputPath).toBeDefined()
+        expect(result.outputPath).toContain("tool_")
+
+        const fsys = yield* FSUtil.Service
+        const written = yield* fsys.readFileString(result.outputPath!)
+        expect(written).toBe(lines)
+      }),
+    )
+
+    it.live("suggests Task tool when agent has task permission", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+        const agent = { permission: [{ permission: "task", pattern: "*", action: "allow" as const }] }
+        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("Grep")
+        expect(result.content).toContain("Task tool")
+      }),
+    )
+
+    it.live("omits Task tool hint when agent lacks task permission", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const lines = Array.from({ length: 100 }, (_, i) => `line${i}`).join("\n")
+        const agent = { permission: [{ permission: "task", pattern: "*", action: "deny" as const }] }
+        const result = yield* svc.output(lines, { maxLines: 10 }, agent as any)
+
+        expect(result.truncated).toBe(true)
+        expect(result.content).toContain("Grep")
+        expect(result.content).not.toContain("Task tool")
+      }),
+    )
+
+    it.live("does not write file when not truncated", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const content = "short content"
+        const result = yield* svc.output(content)
+
+        expect(result.truncated).toBe(false)
+        if (result.truncated) throw new Error("expected not truncated")
+        expect("outputPath" in result).toBe(false)
+      }),
+    )
+
+    test("loads truncate effect in a fresh process", async () => {
+      const out = await Process.run([process.execPath, "run", path.join(ROOT, "src", "tool", "truncate.ts")], {
+        cwd: ROOT,
+      })
+
+      expect(out.code).toBe(0)
+    }, 20000)
+  })
+
+  describe("cleanup", () => {
+    const DAY_MS = 24 * 60 * 60 * 1000
+
+    it.live("deletes files older than 7 days and preserves recent files", () =>
+      Effect.gen(function* () {
+        const svc = yield* Truncate.Service
+        const fs = yield* FileSystem.FileSystem
+
+        yield* fs.makeDirectory(Truncate.DIR, { recursive: true })
+
+        const old = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 10 * DAY_MS))
+        const recent = path.join(Truncate.DIR, Identifier.create("tool", "ascending", Date.now() - 3 * DAY_MS))
+
+        yield* writeFileStringScoped(old, "old content")
+        yield* writeFileStringScoped(recent, "recent content")
+        yield* svc.cleanup()
+
+        expect(yield* fs.exists(old)).toBe(false)
+        expect(yield* fs.exists(recent)).toBe(true)
+      }),
+    )
+  })
+})

package/test/tool/webfetch.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect } from "bun:test"
+import { LayerNode } from "@ac/core/effect/layer-node"
+import { httpClient } from "@ac/core/effect/app-node-platform"
+import { Effect, Layer } from "effect"
+import { FetchHttpClient, HttpClient } from "effect/unstable/http"
+import { Agent } from "../../src/agent/agent"
+import { Truncate } from "@/tool/truncate"
+import { WebFetchTool } from "../../src/tool/webfetch"
+import { SessionID, MessageID } from "../../src/session/schema"
+import { Tool } from "@/tool/tool"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(
+  LayerNode.compile(LayerNode.group([httpClient, Truncate.node, Agent.node]), [
+    [httpClient, FetchHttpClient.layer as Layer.Layer<HttpClient.HttpClient>],
+  ]),
+)
+
+const ctx = {
+  sessionID: SessionID.make("ses_test"),
+  messageID: MessageID.make("msg_message"),
+  callID: "",
+  agent: "build",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+  ask: () => Effect.void,
+}
+
+const withFetch = <A, E, R>(
+  fetch: (req: Request) => Response | Promise<Response>,
+  fn: (url: URL) => Effect.Effect<A, E, R>,
+) =>
+  Effect.acquireUseRelease(
+    Effect.sync(() => Bun.serve({ port: 0, fetch })),
+    (server) => fn(server.url),
+    (server) => Effect.sync(() => server.stop(true)),
+  )
+
+const exec = Effect.fn("WebFetchToolTest.exec")(function* (args: Tool.InferParameters<typeof WebFetchTool>) {
+  const info = yield* WebFetchTool
+  const tool = yield* info.init()
+  return yield* tool.execute(args, ctx)
+})
+
+describe("tool.webfetch", () => {
+  it.instance("returns image responses as file attachments", () =>
+    Effect.gen(function* () {
+      const bytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
+      yield* withFetch(
+        () => new Response(bytes, { status: 200, headers: { "content-type": "IMAGE/PNG; charset=binary" } }),
+        (url) =>
+          Effect.gen(function* () {
+            const result = yield* exec({ url: new URL("/image.png", url).toString(), format: "markdown" })
+            expect(result.output).toBe("Image fetched successfully")
+            expect(result.attachments).toBeDefined()
+            expect(result.attachments?.length).toBe(1)
+            expect(result.attachments?.[0].type).toBe("file")
+            expect(result.attachments?.[0].mime).toBe("image/png")
+            expect(result.attachments?.[0].url.startsWith("data:image/png;base64,")).toBe(true)
+            expect(result.attachments?.[0]).not.toHaveProperty("id")
+            expect(result.attachments?.[0]).not.toHaveProperty("sessionID")
+            expect(result.attachments?.[0]).not.toHaveProperty("messageID")
+          }),
+      )
+    }),
+  )
+
+  it.instance("keeps svg as text output", () =>
+    withFetch(
+      () =>
+        new Response('<svg xmlns="http://www.w3.org/2000/svg"><text>hello</text></svg>', {
+          status: 200,
+          headers: { "content-type": "image/svg+xml; charset=UTF-8" },
+        }),
+      (url) =>
+        Effect.gen(function* () {
+          const result = yield* exec({ url: new URL("/image.svg", url).toString(), format: "html" })
+          expect(result.output).toContain("<svg")
+          expect(result.attachments).toBeUndefined()
+        }),
+    ),
+  )
+
+  it.instance("keeps text responses as text output", () =>
+    withFetch(
+      () =>
+        new Response("hello from webfetch", {
+          status: 200,
+          headers: { "content-type": "text/plain; charset=utf-8" },
+        }),
+      (url) =>
+        Effect.gen(function* () {
+          const result = yield* exec({ url: new URL("/file.txt", url).toString(), format: "text" })
+          expect(result.output).toBe("hello from webfetch")
+          expect(result.attachments).toBeUndefined()
+        }),
+    ),
+  )
+
+  it.instance("extracts text from html without scripts or styles", () =>
+    withFetch(
+      () =>
+        new Response(
+          "<html><head><style>.hidden{}</style><script>alert('x')</script></head><body>Hello <b>world</b></body></html>",
+          {
+            status: 200,
+            headers: { "content-type": "text/html; charset=utf-8" },
+          },
+        ),
+      (url) =>
+        Effect.gen(function* () {
+          const result = yield* exec({ url: new URL("/page.html", url).toString(), format: "text" })
+          expect(result.output).toBe("Hello world")
+          expect(result.attachments).toBeUndefined()
+        }),
+    ),
+  )
+})

package/test/tool/websearch.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { parseResponse } from "../../src/tool/mcp-websearch"
+import { selectWebSearchProvider, webSearchModelName, webSearchProviderLabel } from "../../src/tool/websearch"
+
+import { webSearchEnabled } from "../../src/tool/registry"
+import { it } from "../lib/effect"
+import { ProviderV2 } from "@ac/core/provider"
+
+const SESSION_ID = "ses_0196aabbccddeeff001122334455"
+
+describe("websearch provider", () => {
+  test("selects a stable provider per session", () => {
+    expect(selectWebSearchProvider(SESSION_ID)).toBe(selectWebSearchProvider(SESSION_ID))
+  })
+
+  test("supports an operational override", () => {
+    const original = process.env.AC_WEBSEARCH_PROVIDER
+
+    try {
+      process.env.AC_WEBSEARCH_PROVIDER = "parallel"
+      expect(selectWebSearchProvider(SESSION_ID)).toBe("parallel")
+
+      process.env.AC_WEBSEARCH_PROVIDER = "exa"
+      expect(selectWebSearchProvider(SESSION_ID)).toBe("exa")
+    } finally {
+      if (original === undefined) delete process.env.AC_WEBSEARCH_PROVIDER
+      else process.env.AC_WEBSEARCH_PROVIDER = original
+    }
+  })
+
+  test("routes to Exa when the Exa flag is enabled", () => {
+    expect(selectWebSearchProvider(SESSION_ID, { exa: true, parallel: false })).toBe("exa")
+  })
+
+  test("routes to Parallel when the Parallel flag is enabled", () => {
+    expect(selectWebSearchProvider(SESSION_ID, { exa: false, parallel: true })).toBe("parallel")
+  })
+
+  test("is only enabled for opencode or explicit websearch provider flags", () => {
+    expect(webSearchEnabled(ProviderV2.ID.opencode, { exa: false, parallel: false })).toBe(true)
+    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: false, parallel: false })).toBe(false)
+    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: true, parallel: false })).toBe(true)
+    expect(webSearchEnabled(ProviderV2.ID.openai, { exa: false, parallel: true })).toBe(true)
+  })
+
+  test("uses branded labels", () => {
+    expect(webSearchProviderLabel("parallel")).toBe("Parallel Web Search")
+    expect(webSearchProviderLabel("exa")).toBe("Exa Web Search")
+    expect(webSearchProviderLabel(undefined)).toBe("Web Search")
+  })
+
+  test("uses the provider API model id for Parallel analytics", () => {
+    expect(
+      webSearchModelName({
+        model: {
+          id: "claude-opus-4-7",
+          api: { id: "claude-opus-4.7" },
+        },
+      }),
+    ).toBe("claude-opus-4.7")
+  })
+})
+
+describe("websearch MCP response parser", () => {
+  const payload = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    result: {
+      content: [
+        {
+          type: "text",
+          text: "search results",
+        },
+      ],
+    },
+  })
+
+  it.effect("parses plain JSON-RPC responses", () =>
+    Effect.gen(function* () {
+      const result = yield* parseResponse(payload)
+      expect(result).toBe("search results")
+    }),
+  )
+
+  it.effect("parses SSE JSON-RPC responses", () =>
+    Effect.gen(function* () {
+      const result = yield* parseResponse(`event: message\ndata: ${payload}\n\n`)
+      expect(result).toBe("search results")
+    }),
+  )
+
+  it.effect("ignores non-JSON SSE data frames", () =>
+    Effect.gen(function* () {
+      const result = yield* parseResponse(`data: [DONE]\ndata: ${payload}\n\n`)
+      expect(result).toBe("search results")
+    }),
+  )
+})