openAgent

1import { beforeEach, describe, expect, test } from "bun:test"
2import { Effect, Layer, Schema } from "effect"
3import { HttpClient, HttpClientResponse } from "effect/unstable/http"
4import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
5import { LayerNode } from "@opencode-ai/core/effect/layer-node"
6import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
7import { PermissionV2 } from "@opencode-ai/core/permission"
8import { SessionV2 } from "@opencode-ai/core/session"
9import { ToolRegistry } from "@opencode-ai/core/tool/registry"
10import { WebSearchTool } from "@opencode-ai/core/tool/websearch"
11import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
12import { testEffect } from "./lib/effect"
13import { toolIdentity, executeTool, settleTool, toolDefinitions } from "./lib/tool"
14 
15const sessionID = SessionV2.ID.make("ses_websearch_test")
16const payload = (text: string) =>
17  JSON.stringify({
18    jsonrpc: "2.0",
19    id: 1,
20    result: { content: [{ type: "text", text }] },
21  })
22 
23describe("WebSearchTool provider selection", () => {
24  test("rejects out-of-range numeric controls", () => {
25    const decode = Schema.decodeUnknownSync(WebSearchTool.Input)
26    expect(() => decode({ query: "x", numResults: 0 })).toThrow()
27    expect(() => decode({ query: "x", numResults: WebSearchTool.MAX_NUM_RESULTS + 1 })).toThrow()
28    expect(() => decode({ query: "x", contextMaxCharacters: WebSearchTool.MAX_CONTEXT_CHARACTERS + 1 })).toThrow()
29  })
30  test("selects a stable provider per session", () => {
31    expect(WebSearchTool.selectProvider(sessionID)).toBe(WebSearchTool.selectProvider(sessionID))
32  })
33 
34  test("supports an explicit operational override", () => {
35    expect(WebSearchTool.selectProvider(sessionID, { enableExa: false, enableParallel: false }, "parallel")).toBe(
36      "parallel",
37    )
38    expect(WebSearchTool.selectProvider(sessionID, { enableExa: false, enableParallel: false }, "exa")).toBe("exa")
39  })
40 
41  test("prefers Parallel when both explicit flags are enabled", () => {
42    expect(WebSearchTool.selectProvider(sessionID, { enableExa: true, enableParallel: true })).toBe("parallel")
43  })
44 
45  test("prefers Exa when only its explicit flag is enabled", () => {
46    expect(WebSearchTool.selectProvider(sessionID, { enableExa: true, enableParallel: false })).toBe("exa")
47  })
48})
49 
50describe("WebSearchTool MCP response parser", () => {
51  test("parses plain JSON-RPC responses", async () => {
52    expect(await Effect.runPromise(WebSearchTool.parseResponse(payload("search results")))).toBe("search results")
53  })
54 
55  test("parses SSE JSON-RPC responses and ignores non-JSON frames", async () => {
56    expect(
57      await Effect.runPromise(
58        WebSearchTool.parseResponse(`data: [DONE]\nevent: message\ndata: ${payload("search results")}\n\n`),
59      ),
60    ).toBe("search results")
61  })
62})
63 
64interface Request {
65  readonly url: string
66  readonly headers: Record<string, string>
67  readonly body: unknown
68}
69 
70const requests: Request[] = []
71const assertions: PermissionV2.AssertInput[] = []
72let responseBody = payload("search results")
73let makeResponse = () => new Response(responseBody, { status: 200 })
74let config: WebSearchTool.Config = { enableExa: false, enableParallel: false }
75 
76beforeEach(() => {
77  responseBody = payload("search results")
78  makeResponse = () => new Response(responseBody, { status: 200 })
79})
80 
81const http = Layer.succeed(
82  HttpClient.HttpClient,
83  HttpClient.make((request) =>
84    Effect.sync(() => {
85      if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
86      requests.push({
87        url: request.url,
88        headers: request.headers,
89        body: JSON.parse(new TextDecoder().decode(request.body.body)),
90      })
91      return HttpClientResponse.fromWeb(request, makeResponse())
92    }),
93  ),
94)
95const permission = Layer.succeed(
96  PermissionV2.Service,
97  PermissionV2.Service.of({
98    assert: (input) => Effect.sync(() => assertions.push(input)),
99    ask: () => Effect.die("unused"),
100    reply: () => Effect.die("unused"),
101    get: () => Effect.die("unused"),
102    forSession: () => Effect.die("unused"),
103    list: () => Effect.die("unused"),
104  }),
105)
106const websearchConfig = Layer.succeed(
107  WebSearchTool.ConfigService,
108  WebSearchTool.ConfigService.of({
109    get provider() {
110      return config.provider
111    },
112    get enableExa() {
113      return config.enableExa
114    },
115    get enableParallel() {
116      return config.enableParallel
117    },
118    get exaApiKey() {
119      return config.exaApiKey
120    },
121    get parallelApiKey() {
122      return config.parallelApiKey
123    },
124  }),
125)
126const it = testEffect(
127  AppNodeBuilder.build(
128    LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, WebSearchTool.configNode, WebSearchTool.node]),
129    [
130      [PermissionV2.node, permission],
131      [LayerNodePlatform.httpClient, http],
132      [WebSearchTool.configNode, websearchConfig],
133      [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
134    ],
135  ),
136)
137 
138describe("WebSearchTool registration", () => {
139  it.effect("registers websearch, asserts query permission, and calls Exa", () =>
140    Effect.gen(function* () {
141      requests.length = 0
142      assertions.length = 0
143      responseBody = payload("exa results")
144      config = { provider: "exa", enableExa: false, enableParallel: false }
145      const registry = yield* ToolRegistry.Service
146 
147      expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["websearch"])
148      expect(
149        yield* executeTool(registry, {
150          sessionID,
151          ...toolIdentity,
152          call: {
153            type: "tool-call",
154            id: "call-exa",
155            name: "websearch",
156            input: {
157              query: "effect typescript",
158              numResults: 3,
159              livecrawl: "preferred",
160              type: "fast",
161              contextMaxCharacters: 2500,
162            },
163          },
164        }),
165      ).toEqual({ type: "text", value: "exa results" })
166      expect(assertions).toMatchObject([
167        {
168          sessionID,
169          action: "websearch",
170          resources: ["effect typescript"],
171          save: ["*"],
172          metadata: {
173            query: "effect typescript",
174            numResults: 3,
175            livecrawl: "preferred",
176            type: "fast",
177            contextMaxCharacters: 2500,
178            provider: "exa",
179          },
180        },
181      ])
182      expect(requests).toEqual([
183        {
184          url: WebSearchTool.EXA_URL,
185          headers: expect.any(Object),
186          body: {
187            jsonrpc: "2.0",
188            id: 1,
189            method: "tools/call",
190            params: {
191              name: "web_search_exa",
192              arguments: {
193                query: "effect typescript",
194                type: "fast",
195                numResults: 3,
196                livecrawl: "preferred",
197                contextMaxCharacters: 2500,
198              },
199            },
200          },
201        },
202      ])
203    }),
204  )
205 
206  it.effect("calls Parallel with session ID and keeps bearer credentials out of output", () =>
207    Effect.gen(function* () {
208      requests.length = 0
209      assertions.length = 0
210      responseBody = payload("parallel results")
211      config = { provider: "parallel", enableExa: false, enableParallel: false, parallelApiKey: "parallel-secret" }
212      const registry = yield* ToolRegistry.Service
213 
214      const settled = yield* settleTool(registry, {
215        sessionID,
216        ...toolIdentity,
217        call: { type: "tool-call", id: "call-parallel", name: "websearch", input: { query: "effect layers" } },
218      })
219 
220      expect(requests[0]).toMatchObject({
221        url: WebSearchTool.PARALLEL_URL,
222        headers: { authorization: "Bearer parallel-secret" },
223        body: {
224          jsonrpc: "2.0",
225          id: 1,
226          method: "tools/call",
227          params: {
228            name: "web_search",
229            arguments: { objective: "effect layers", search_queries: ["effect layers"], session_id: sessionID },
230          },
231        },
232      })
233      expect(requests[0]?.body).not.toHaveProperty("params.arguments.model_name")
234      expect(settled).toEqual({
235        result: { type: "text", value: "parallel results" },
236        output: {
237          structured: { provider: "parallel", text: "parallel results" },
238          content: [{ type: "text", text: "parallel results" }],
239        },
240      })
241      expect(JSON.stringify(settled)).not.toContain("parallel-secret")
242    }),
243  )
244 
245  it.effect("keeps an Exa credential in the transport URL and out of model output", () =>
246    Effect.gen(function* () {
247      requests.length = 0
248      assertions.length = 0
249      responseBody = payload("credentialed exa results")
250      config = { provider: "exa", enableExa: false, enableParallel: false, exaApiKey: "exa secret" }
251      const registry = yield* ToolRegistry.Service
252 
253      const settled = yield* settleTool(registry, {
254        sessionID,
255        ...toolIdentity,
256        call: { type: "tool-call", id: "call-exa-key", name: "websearch", input: { query: "effect schema" } },
257      })
258 
259      expect(requests[0]?.url).toBe(`${WebSearchTool.EXA_URL}?exaApiKey=exa+secret`)
260      expect(JSON.stringify(settled)).not.toContain("exa secret")
261    }),
262  )
263 
264  it.effect("returns the legacy no-results fallback as concise model text", () =>
265    Effect.gen(function* () {
266      requests.length = 0
267      assertions.length = 0
268      responseBody = ""
269      config = { provider: "exa", enableExa: false, enableParallel: false }
270      const registry = yield* ToolRegistry.Service
271 
272      expect(
273        yield* executeTool(registry, {
274          sessionID,
275          ...toolIdentity,
276          call: { type: "tool-call", id: "call-empty", name: "websearch", input: { query: "nothing" } },
277        }),
278      ).toEqual({ type: "text", value: WebSearchTool.NO_RESULTS })
279    }),
280  )
281 
282  it.effect("rejects oversized MCP response bodies", () =>
283    Effect.gen(function* () {
284      requests.length = 0
285      assertions.length = 0
286      let chunksRead = 0
287      let cancelled = false
288      makeResponse = () =>
289        new Response(
290          new ReadableStream({
291            pull(controller) {
292              chunksRead++
293              if (chunksRead === 10) throw new Error("response was not stopped at the byte limit")
294              controller.enqueue(new Uint8Array(64 * 1024))
295            },
296            cancel() {
297              cancelled = true
298            },
299          }),
300          { status: 200 },
301        )
302      config = { provider: "exa", enableExa: false, enableParallel: false }
303      const registry = yield* ToolRegistry.Service
304 
305      expect(
306        yield* executeTool(registry, {
307          sessionID,
308          ...toolIdentity,
309          call: { type: "tool-call", id: "call-large-response", name: "websearch", input: { query: "too much" } },
310        }),
311      ).toEqual({ type: "error", value: "Unable to search the web for too much" })
312      expect(chunksRead).toBeLessThan(10)
313      expect(cancelled).toBe(true)
314    }),
315  )
316})
317