feat(core): add integration-backed search

packages/core/test/form.test.ts

@@ -4,6 +4,7 @@ import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { Form } from "@opencode-ai/core/form"
+import { Integration } from "@opencode-ai/core/integration"
 import { SessionSchema } from "@opencode-ai/core/session/schema"
 import { testEffect } from "./lib/effect"
 
@@ -59,6 +60,27 @@ describe("Form", () => {
     }),
   )
 
+  it.effect("uses an empty reply to complete an integration form", () =>
+    Effect.gen(function* () {
+      const service = yield* Form.Service
+      const created = yield* service.create({
+        sessionID: "ses_test",
+        mode: "integration",
+        integrationID: Integration.ID.make("exa"),
+      })
+
+      const invalid = yield* service.reply({ id: created.id, answer: { connected: true } }).pipe(Effect.flip)
+      expect(invalid).toEqual(
+        new Form.InvalidAnswerError({
+          id: created.id,
+          message: "Integration forms must be answered with an empty answer",
+        }),
+      )
+      yield* service.reply({ id: created.id, answer: {} })
+      expect(yield* service.state(created.id)).toEqual({ status: "answered", answer: {} })
+    }),
+  )
+
   it.effect("gates required fields and rejects inactive answers via when", () =>
     Effect.gen(function* () {
       const service = yield* Form.Service

packages/core/test/integration.test.ts

@@ -21,7 +21,7 @@ describe("Integration", () => {
         .transform((editor) => editor.update(openai, (integration) => (integration.name = "OpenAI")))
         .pipe(Scope.provide(scope))
       expect(yield* integrations.get(openai)).toEqual(
-        new Integration.Info({ id: openai, name: "OpenAI", methods: [], connections: [] }),
+        new Integration.Info({ id: openai, name: "OpenAI", methods: [], capabilities: [], connections: [] }),
       )
 
       yield* Scope.close(scope, Exit.void)

packages/core/test/plugin/host.ts

@@ -45,6 +45,7 @@ export function host(overrides: Overrides = {}): PluginContext {
     integration: overrides.integration ?? {
       list: () => Effect.die("unused integration.list"),
       get: () => Effect.die("unused integration.get"),
+      selectCapability: () => Effect.die("unused integration.selectCapability"),
       connectKey: () => Effect.die("unused integration.connectKey"),
       connectOauth: () => Effect.die("unused integration.connectOauth"),
       attemptStatus: () => Effect.die("unused integration.attemptStatus"),
@@ -188,6 +189,7 @@ export function integrationHost(integration: Integration.Interface): PluginConte
   return {
     list: () => Effect.die("unused integration.list"),
     get: () => Effect.die("unused integration.get"),
+    selectCapability: () => Effect.die("unused integration.selectCapability"),
     connectKey: () => Effect.die("unused integration.connectKey"),
     connectOauth: () => Effect.die("unused integration.connectOauth"),
     attemptStatus: () => Effect.die("unused integration.attemptStatus"),
@@ -281,6 +283,18 @@ export function integrationHost(integration: Integration.Interface): PluginConte
             },
             remove: (id, item) => draft.method.remove(Integration.ID.make(id), internalMethod(item)),
           },
+          capability: {
+            search: {
+              list: () => [],
+              update: (input) =>
+                draft.capability.search.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  capability: input.capability,
+                  execute: input.execute,
+                }),
+              remove: (id) => draft.capability.search.remove(Integration.ID.make(id)),
+            },
+          },
         }),
       ),
   }

packages/core/test/plugin/models-dev.test.ts

@@ -156,6 +156,7 @@ describe("ModelsDevPlugin", () => {
                   names: ["ACME_API_KEY"],
                 },
               ],
+              capabilities: [],
               connections: [],
             }),
           ])

packages/core/test/plugin/promise.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { AgentV2 } from "@opencode-ai/core/agent"
+import { Integration } from "@opencode-ai/core/integration"
 import { PluginV2 } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginPromise } from "@opencode-ai/core/plugin/promise"
@@ -93,4 +94,29 @@ describe("fromPromise", () => {
       expect(yield* agents.get(AgentV2.ID.make("temp"))).toBeUndefined()
     }),
   )
+
+  it.effect("adapts promise search capability execution", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const plugin = yield* PluginV2.Service
+      const host = yield* PluginHost.make(plugin)
+      const promisePlugin = define({
+        id: "promise-search",
+        setup: async (ctx) => {
+          await ctx.integration.transform((draft) => {
+            draft.capability.search.update({
+              integrationID: "promise-search",
+              capability: { type: "search", connection: "optional" },
+              execute: async (input) => ({ text: `promise: ${input.query}` }),
+            })
+          })
+        },
+      })
+
+      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
+      const provider = yield* integrations.capability.search.get(Integration.ID.make("promise-search"))
+      if (!provider) return yield* Effect.die("Expected promise search provider")
+      expect(yield* provider.execute({ query: "effect" }, {})).toEqual({ text: "promise: effect" })
+    }),
+  )
 })

packages/core/test/plugin/search-fixture.ts

@@ -0,0 +1,41 @@
+import { Effect, Layer } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Credential } from "@opencode-ai/core/credential"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Integration } from "@opencode-ai/core/integration"
+import { testEffect } from "../lib/effect"
+
+export interface SearchRequest {
+  readonly url: string
+  readonly headers: Record<string, string>
+  readonly body: unknown
+}
+
+export const requests: SearchRequest[] = []
+export const response = { body: "" }
+
+export function resetSearchFixture(body: string) {
+  requests.length = 0
+  response.body = body
+}
+
+const http = Layer.succeed(
+  HttpClient.HttpClient,
+  HttpClient.make((request) =>
+    Effect.sync(() => {
+      if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
+      requests.push({
+        url: request.url,
+        headers: request.headers,
+        body: JSON.parse(new TextDecoder().decode(request.body.body)),
+      })
+      return HttpClientResponse.fromWeb(request, new Response(response.body, { status: 200 }))
+    }),
+  ),
+)
+
+export const searchIntegrationTest = testEffect(
+  Layer.merge(AppNodeBuilder.build(LayerNode.group([Integration.node, Credential.node, EventV2.node])), http),
+)

packages/core/test/plugin/search.test.ts

@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Credential } from "@opencode-ai/core/credential"
+import { Integration } from "@opencode-ai/core/integration"
+import { SearchExa } from "@opencode-ai/core/plugin/search/exa"
+import { SearchParallel } from "@opencode-ai/core/plugin/search/parallel"
+import { host, integrationHost } from "./host"
+import { requests, resetSearchFixture, searchIntegrationTest } from "./search-fixture"
+
+beforeEach(() => {
+  resetSearchFixture(
+    JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      result: { content: [{ type: "text", text: "search results" }] },
+    }),
+  )
+})
+
+const it = searchIntegrationTest
+
+describe("built-in search integrations", () => {
+  it.effect("registers Exa and maps search hints to its MCP tool", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      yield* SearchExa.Plugin.effect(host({ integration: integrationHost(integrations) }))
+
+      const info = yield* integrations.get(Integration.ID.make("exa"))
+      expect(info).toMatchObject({
+        id: "exa",
+        name: "Exa",
+        methods: [{ type: "key" }, { type: "env", names: ["EXA_API_KEY"] }],
+        capabilities: [{ type: "search", connection: "optional", selected: false }],
+      })
+      const provider = yield* integrations.capability.search.get(Integration.ID.make("exa"))
+      if (!provider) return yield* Effect.die("Expected Exa search provider")
+      expect(
+        yield* provider.execute(
+          {
+            query: "effect typescript",
+            numResults: 3,
+            livecrawl: "preferred",
+            type: "fast",
+            contextMaxCharacters: 2500,
+          },
+          { credential: Credential.Key.make({ type: "key", key: "exa secret" }) },
+        ),
+      ).toEqual({ text: "search results" })
+      expect(requests).toEqual([
+        {
+          url: `${SearchExa.endpoint}?exaApiKey=exa+secret`,
+          headers: expect.any(Object),
+          body: {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: {
+              name: "web_search_exa",
+              arguments: {
+                query: "effect typescript",
+                type: "fast",
+                numResults: 3,
+                livecrawl: "preferred",
+                contextMaxCharacters: 2500,
+              },
+            },
+          },
+        },
+      ])
+    }),
+  )
+
+  it.effect("registers Parallel and keeps its credential in the authorization header", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      yield* SearchParallel.Plugin.effect(host({ integration: integrationHost(integrations) }))
+      const provider = yield* integrations.capability.search.get(Integration.ID.make("parallel"))
+      if (!provider) return yield* Effect.die("Expected Parallel search provider")
+
+      const output = yield* provider.execute(
+        { query: "effect layers" },
+        {
+          sessionID: "ses_parallel",
+          credential: Credential.Key.make({ type: "key", key: "parallel-secret" }),
+        },
+      )
+      expect(output).toEqual({ text: "search results" })
+      expect(requests[0]).toMatchObject({
+        url: SearchParallel.endpoint,
+        headers: { authorization: "Bearer parallel-secret" },
+        body: {
+          jsonrpc: "2.0",
+          id: 1,
+          method: "tools/call",
+          params: {
+            name: "web_search",
+            arguments: {
+              objective: "effect layers",
+              search_queries: ["effect layers"],
+              session_id: "ses_parallel",
+            },
+          },
+        },
+      })
+      expect(JSON.stringify(output)).not.toContain("parallel-secret")
+    }),
+  )
+
+})

packages/core/test/search.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect } from "bun:test"
+import { Effect, Exit, Fiber, Layer, Scope } from "effect"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { Config } from "@opencode-ai/core/config"
+import { ConfigSearch } from "@opencode-ai/core/config/search"
+import { Credential } from "@opencode-ai/core/credential"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Form } from "@opencode-ai/core/form"
+import { Integration } from "@opencode-ai/core/integration"
+import { Search } from "@opencode-ai/core/search"
+import { testEffect } from "./lib/effect"
+
+let entries: Config.Entry[] = []
+const config = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed(entries) }))
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([Search.node, Integration.node, Credential.node, EventV2.node, Form.node]), [
+    [Config.node, config],
+  ]),
+)
+
+const register = (id: string, connection: "optional" | "required" = "optional") =>
+  Effect.gen(function* () {
+    const integrations = yield* Integration.Service
+    const integrationID = Integration.ID.make(id)
+    const calls: { input: Search.Input; credential?: Credential.Value; sessionID?: string }[] = []
+    yield* integrations.transform((draft) => {
+      draft.update(integrationID, (integration) => (integration.name = id.toUpperCase()))
+      draft.capability.search.update({
+        integrationID,
+        capability: { type: "search", connection },
+        execute: (input, context) =>
+          Effect.sync(() => {
+            calls.push({ input, ...context })
+            return { text: `${id}: ${input.query}`, metadata: { id } }
+          }),
+      })
+    })
+    return { integrationID, calls }
+  })
+
+beforeEach(() => {
+  entries = []
+})
+
+describe("Search", () => {
+  it.effect("executes an explicit provider without changing the default", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("exa")
+      const search = yield* Search.Service
+      const integrations = yield* Integration.Service
+
+      expect(yield* search.query({ query: "effect", providerID: provider.integrationID })).toEqual(
+        new Search.Result({
+          providerID: provider.integrationID,
+          text: "exa: effect",
+          metadata: { id: "exa" },
+        }),
+      )
+      expect(yield* integrations.capability.search.selected()).toBeUndefined()
+      expect(provider.calls).toEqual([
+        {
+          input: { query: "effect", providerID: provider.integrationID },
+          credential: undefined,
+          sessionID: undefined,
+        },
+      ])
+    }),
+  )
+
+  it.effect("uses the persisted integration capability selection", () =>
+    Effect.gen(function* () {
+      yield* register("exa")
+      const parallel = yield* register("parallel")
+      const integrations = yield* Integration.Service
+      const search = yield* Search.Service
+      yield* integrations.capability.search.select(parallel.integrationID)
+
+      expect((yield* search.query({ query: "layers" })).providerID).toBe(parallel.integrationID)
+      expect((yield* integrations.get(parallel.integrationID))?.capabilities).toEqual([
+        { type: "search", connection: "optional", selected: true },
+      ])
+    }),
+  )
+
+  it.effect("prefers the location config over the global selection", () =>
+    Effect.gen(function* () {
+      const exa = yield* register("exa")
+      const parallel = yield* register("parallel")
+      const integrations = yield* Integration.Service
+      const search = yield* Search.Service
+      yield* integrations.capability.search.select(exa.integrationID)
+      entries = [
+        new Config.Document({
+          type: "document",
+          info: new Config.Info({ search: new ConfigSearch.Info({ provider: parallel.integrationID }) }),
+        }),
+      ]
+
+      expect((yield* search.query({ query: "configured" })).providerID).toBe(parallel.integrationID)
+    }),
+  )
+
+  it.effect("serializes concurrent first-use onboarding and persists the answer", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("exa")
+      const search = yield* Search.Service
+      const forms = yield* Form.Service
+      const integrations = yield* Integration.Service
+      const first = yield* search.query({ query: "one", sessionID: "ses_search" }).pipe(Effect.forkChild)
+      const second = yield* search.query({ query: "two", sessionID: "ses_search" }).pipe(Effect.forkChild)
+      yield* Effect.yieldNow
+
+      const pending = yield* forms.list({ sessionID: "ses_search" })
+      expect(pending).toHaveLength(1)
+      const form = pending[0]
+      if (!form) return yield* Effect.die("Expected an onboarding form")
+      yield* forms.reply({ id: form.id, answer: { provider: provider.integrationID } })
+
+      expect((yield* Fiber.join(first)).providerID).toBe(provider.integrationID)
+      expect((yield* Fiber.join(second)).providerID).toBe(provider.integrationID)
+      expect(yield* integrations.capability.search.selected()).toBe(provider.integrationID)
+    }),
+  )
+
+  it.effect("requires a connection before invoking a required provider", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("private", "required")
+      const search = yield* Search.Service
+
+      expect(
+        yield* search.query({ query: "secret", providerID: provider.integrationID }).pipe(Effect.flip),
+      ).toBeInstanceOf(Search.ConnectionRequiredError)
+      expect(provider.calls).toEqual([])
+    }),
+  )
+
+  it.effect("removes scoped provider registrations", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const scope = yield* Scope.fork(yield* Scope.Scope)
+      const provider = yield* register("temporary").pipe(Scope.provide(scope))
+      expect(yield* integrations.capability.search.get(provider.integrationID)).toBeDefined()
+      yield* Scope.close(scope, Exit.void)
+      expect(yield* integrations.capability.search.get(provider.integrationID)).toBeUndefined()
+    }),
+  )
+})

packages/core/test/tool-websearch.test.ts

@@ -1,22 +1,22 @@
 import { beforeEach, describe, expect, test } from "bun:test"
 import { Effect, Layer, Schema } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { LayerNodePlatform } from "@opencode-ai/core/effect/app-node-platform"
 import { PermissionV2 } from "@opencode-ai/core/permission"
+import { Integration } from "@opencode-ai/core/integration"
+import { Search } from "@opencode-ai/core/search"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
 import { WebSearchTool } from "@opencode-ai/core/tool/websearch"
 import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
 import { makeLocationNode } from "@opencode-ai/core/effect/app-node"
 import { testEffect } from "./lib/effect"
-import { toolIdentity, executeTool, registerToolPlugin, settleTool, toolDefinitions } from "./lib/tool"
+import { executeTool, registerToolPlugin, settleTool, toolDefinitions, toolIdentity } from "./lib/tool"
 
 const webSearchToolNode = makeLocationNode({
   name: "test/websearch-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(WebSearchTool.Plugin)),
-  deps: [ToolRegistry.toolsNode, PermissionV2.node, LayerNodePlatform.httpClient, WebSearchTool.configNode],
+  deps: [ToolRegistry.toolsNode, PermissionV2.node, Search.node],
 })
 
 const sessionID = SessionV2.ID.make("ses_websearch_test")
@@ -27,31 +27,13 @@ const payload = (text: string) =>
     result: { content: [{ type: "text", text }] },
   })
 
-describe("WebSearchTool provider selection", () => {
+describe("WebSearchTool input", () => {
   test("rejects out-of-range numeric controls", () => {
     const decode = Schema.decodeUnknownSync(WebSearchTool.Input)
     expect(() => decode({ query: "x", numResults: 0 })).toThrow()
     expect(() => decode({ query: "x", numResults: WebSearchTool.MAX_NUM_RESULTS + 1 })).toThrow()
     expect(() => decode({ query: "x", contextMaxCharacters: WebSearchTool.MAX_CONTEXT_CHARACTERS + 1 })).toThrow()
   })
-  test("selects a stable provider per session", () => {
-    expect(WebSearchTool.selectProvider(sessionID)).toBe(WebSearchTool.selectProvider(sessionID))
-  })
-
-  test("supports an explicit operational override", () => {
-    expect(WebSearchTool.selectProvider(sessionID, { enableExa: false, enableParallel: false }, "parallel")).toBe(
-      "parallel",
-    )
-    expect(WebSearchTool.selectProvider(sessionID, { enableExa: false, enableParallel: false }, "exa")).toBe("exa")
-  })
-
-  test("prefers Parallel when both explicit flags are enabled", () => {
-    expect(WebSearchTool.selectProvider(sessionID, { enableExa: true, enableParallel: true })).toBe("parallel")
-  })
-
-  test("prefers Exa when only its explicit flag is enabled", () => {
-    expect(WebSearchTool.selectProvider(sessionID, { enableExa: true, enableParallel: false })).toBe("exa")
-  })
 })
 
 describe("WebSearchTool MCP response parser", () => {
@@ -68,37 +50,16 @@ describe("WebSearchTool MCP response parser", () => {
   })
 })
 
-interface Request {
-  readonly url: string
-  readonly headers: Record<string, string>
-  readonly body: unknown
-}
-
-const requests: Request[] = []
 const assertions: PermissionV2.AssertInput[] = []
-let responseBody = payload("search results")
-let makeResponse = () => new Response(responseBody, { status: 200 })
-let config: WebSearchTool.Config = { enableExa: false, enableParallel: false }
+const queries: Search.QueryInput[] = []
+let result = new Search.Result({ providerID: Integration.ID.make("exa"), text: "search results" })
 
 beforeEach(() => {
-  responseBody = payload("search results")
-  makeResponse = () => new Response(responseBody, { status: 200 })
+  assertions.length = 0
+  queries.length = 0
+  result = new Search.Result({ providerID: Integration.ID.make("exa"), text: "search results" })
 })
 
-const http = Layer.succeed(
-  HttpClient.HttpClient,
-  HttpClient.make((request) =>
-    Effect.sync(() => {
-      if (request.body._tag !== "Uint8Array") throw new Error(`Unexpected request body: ${request.body._tag}`)
-      requests.push({
-        url: request.url,
-        headers: request.headers,
-        body: JSON.parse(new TextDecoder().decode(request.body.body)),
-      })
-      return HttpClientResponse.fromWeb(request, makeResponse())
-    }),
-  ),
-)
 const permission = Layer.succeed(
   PermissionV2.Service,
   PermissionV2.Service.of({
@@ -110,45 +71,27 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const websearchConfig = Layer.succeed(
-  WebSearchTool.ConfigService,
-  WebSearchTool.ConfigService.of({
-    get provider() {
-      return config.provider
-    },
-    get enableExa() {
-      return config.enableExa
-    },
-    get enableParallel() {
-      return config.enableParallel
-    },
-    get exaApiKey() {
-      return config.exaApiKey
-    },
-    get parallelApiKey() {
-      return config.parallelApiKey
-    },
+const search = Layer.succeed(
+  Search.Service,
+  Search.Service.of({
+    query: (input) =>
+      Effect.sync(() => {
+        queries.push(input)
+        return result
+      }),
   }),
 )
 const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, WebSearchTool.configNode, webSearchToolNode]),
-    [
-      [PermissionV2.node, permission],
-      [LayerNodePlatform.httpClient, http],
-      [WebSearchTool.configNode, websearchConfig],
-      [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
-    ],
-  ),
+  AppNodeBuilder.build(LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, Search.node, webSearchToolNode]), [
+    [PermissionV2.node, permission],
+    [Search.node, search],
+    [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
+  ]),
 )
 
 describe("WebSearchTool registration", () => {
-  it.effect("registers websearch, asserts query permission, and calls Exa", () =>
+  it.effect("asserts permission before delegating to Search", () =>
     Effect.gen(function* () {
-      requests.length = 0
-      assertions.length = 0
-      responseBody = payload("exa results")
-      config = { provider: "exa", enableExa: false, enableParallel: false }
       const registry = yield* ToolRegistry.Service
 
       expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["websearch"])
@@ -158,7 +101,7 @@ describe("WebSearchTool registration", () => {
           ...toolIdentity,
           call: {
             type: "tool-call",
-            id: "call-exa",
+            id: "call-search",
             name: "websearch",
             input: {
               query: "effect typescript",
@@ -169,7 +112,7 @@ describe("WebSearchTool registration", () => {
             },
           },
         }),
-      ).toEqual({ type: "text", value: "exa results" })
+      ).toEqual({ type: "text", value: "search results" })
       expect(assertions).toMatchObject([
         {
           sessionID,
@@ -182,98 +125,50 @@ describe("WebSearchTool registration", () => {
             livecrawl: "preferred",
             type: "fast",
             contextMaxCharacters: 2500,
-            provider: "exa",
           },
         },
       ])
-      expect(requests).toEqual([
+      expect(queries).toEqual([
         {
-          url: WebSearchTool.EXA_URL,
-          headers: expect.any(Object),
-          body: {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "tools/call",
-            params: {
-              name: "web_search_exa",
-              arguments: {
-                query: "effect typescript",
-                type: "fast",
-                numResults: 3,
-                livecrawl: "preferred",
-                contextMaxCharacters: 2500,
-              },
-            },
-          },
+          sessionID,
+          query: "effect typescript",
+          numResults: 3,
+          livecrawl: "preferred",
+          type: "fast",
+          contextMaxCharacters: 2500,
         },
       ])
     }),
   )
 
-  it.effect("calls Parallel with session ID and keeps bearer credentials out of output", () =>
+  it.effect("keeps provider metadata in structured output", () =>
     Effect.gen(function* () {
-      requests.length = 0
-      assertions.length = 0
-      responseBody = payload("parallel results")
-      config = { provider: "parallel", enableExa: false, enableParallel: false, parallelApiKey: "parallel-secret" }
+      result = new Search.Result({
+        providerID: Integration.ID.make("parallel"),
+        text: "parallel results",
+        metadata: { requestID: "req_1" },
+      })
       const registry = yield* ToolRegistry.Service
 
-      const settled = yield* settleTool(registry, {
-        sessionID,
-        ...toolIdentity,
-        call: { type: "tool-call", id: "call-parallel", name: "websearch", input: { query: "effect layers" } },
-      })
-
-      expect(requests[0]).toMatchObject({
-        url: WebSearchTool.PARALLEL_URL,
-        headers: { authorization: "Bearer parallel-secret" },
-        body: {
-          jsonrpc: "2.0",
-          id: 1,
-          method: "tools/call",
-          params: {
-            name: "web_search",
-            arguments: { objective: "effect layers", search_queries: ["effect layers"], session_id: sessionID },
-          },
-        },
-      })
-      expect(requests[0]?.body).not.toHaveProperty("params.arguments.model_name")
-      expect(settled).toEqual({
+      expect(
+        yield* settleTool(registry, {
+          sessionID,
+          ...toolIdentity,
+          call: { type: "tool-call", id: "call-parallel", name: "websearch", input: { query: "effect layers" } },
+        }),
+      ).toEqual({
         result: { type: "text", value: "parallel results" },
         output: {
-          structured: { provider: "parallel", text: "parallel results" },
+          structured: { provider: "parallel", text: "parallel results", metadata: { requestID: "req_1" } },
           content: [{ type: "text", text: "parallel results" }],
         },
       })
-      expect(JSON.stringify(settled)).not.toContain("parallel-secret")
     }),
   )
 
-  it.effect("keeps an Exa credential in the transport URL and out of model output", () =>
+  it.effect("uses the concise no-results fallback", () =>
     Effect.gen(function* () {
-      requests.length = 0
-      assertions.length = 0
-      responseBody = payload("credentialed exa results")
-      config = { provider: "exa", enableExa: false, enableParallel: false, exaApiKey: "exa secret" }
-      const registry = yield* ToolRegistry.Service
-
-      const settled = yield* settleTool(registry, {
-        sessionID,
-        ...toolIdentity,
-        call: { type: "tool-call", id: "call-exa-key", name: "websearch", input: { query: "effect schema" } },
-      })
-
-      expect(requests[0]?.url).toBe(`${WebSearchTool.EXA_URL}?exaApiKey=exa+secret`)
-      expect(JSON.stringify(settled)).not.toContain("exa secret")
-    }),
-  )
-
-  it.effect("returns the legacy no-results fallback as concise model text", () =>
-    Effect.gen(function* () {
-      requests.length = 0
-      assertions.length = 0
-      responseBody = ""
-      config = { provider: "exa", enableExa: false, enableParallel: false }
+      result = new Search.Result({ providerID: Integration.ID.make("exa"), text: "" })
       const registry = yield* ToolRegistry.Service
 
       expect(
@@ -285,39 +180,4 @@ describe("WebSearchTool registration", () => {
       ).toEqual({ type: "text", value: WebSearchTool.NO_RESULTS })
     }),
   )
-
-  it.effect("rejects oversized MCP response bodies", () =>
-    Effect.gen(function* () {
-      requests.length = 0
-      assertions.length = 0
-      let chunksRead = 0
-      let cancelled = false
-      makeResponse = () =>
-        new Response(
-          new ReadableStream({
-            pull(controller) {
-              chunksRead++
-              if (chunksRead === 10) throw new Error("response was not stopped at the byte limit")
-              controller.enqueue(new Uint8Array(64 * 1024))
-            },
-            cancel() {
-              cancelled = true
-            },
-          }),
-          { status: 200 },
-        )
-      config = { provider: "exa", enableExa: false, enableParallel: false }
-      const registry = yield* ToolRegistry.Service
-
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-large-response", name: "websearch", input: { query: "too much" } },
-        }),
-      ).toEqual({ type: "error", value: "Unable to search the web for too much" })
-      expect(chunksRead).toBeLessThan(10)
-      expect(cancelled).toBe(true)
-    }),
-  )
 })