feat(llm): complete provider package entrypoints

# Conflicts:
#	packages/client/src/promise/generated/client.ts
#	packages/client/src/promise/generated/types.ts
#	packages/client/test/promise.test.ts
#	packages/core/src/plugin/host.ts
#	packages/core/src/plugin/internal.ts
#	packages/core/src/plugin/promise.ts
#	packages/core/test/plugin/host.ts
#	packages/plugin/src/v2/effect/index.ts
#	packages/plugin/src/v2/effect/integration.ts
#	packages/plugin/src/v2/promise/index.ts
#	packages/plugin/src/v2/promise/integration.ts
#	packages/protocol/src/client.ts
#	packages/schema/src/index.ts
#	packages/sdk/js/src/v2/gen/sdk.gen.ts

packages/client/src/effect/api.ts

@@ -1,7 +1,9 @@
-import type { ModelApi, ProviderApi } from "./api/api.js"
+import type { ModelApi, ProviderApi, WebsearchApi } from "./api/api.js"
 
 export type * from "./api/api.js"
 
+export type WebSearchApi<E = never> = WebsearchApi<E>
+
 export interface CatalogApi<E = never> {
   readonly provider: ProviderApi<E>
   readonly model: ModelApi<E>

packages/client/src/effect/api/api.ts

@@ -923,6 +923,40 @@ export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
 }
 
+type Endpoint26_0Request = Parameters<RawClient["server.websearch"]["websearch.provider.get"]>[0]
+export type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
+export type Endpoint26_0Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.provider.get"]>>
+export type WebsearchProviderGetOperation<E = never> = (
+  input?: Endpoint26_0Input,
+) => Effect.Effect<Endpoint26_0Output, E>
+
+type Endpoint26_1Request = Parameters<RawClient["server.websearch"]["websearch.provider.select"]>[0]
+export type Endpoint26_1Input = {
+  readonly location?: Endpoint26_1Request["query"]["location"]
+  readonly providerID: Endpoint26_1Request["payload"]["providerID"]
+}
+export type Endpoint26_1Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.provider.select"]>>
+export type WebsearchProviderSelectOperation<E = never> = (
+  input: Endpoint26_1Input,
+) => Effect.Effect<Endpoint26_1Output, E>
+
+type Endpoint26_2Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
+export type Endpoint26_2Input = {
+  readonly location?: Endpoint26_2Request["query"]["location"]
+  readonly query: Endpoint26_2Request["payload"]["query"]
+  readonly providerID?: Endpoint26_2Request["payload"]["providerID"]
+}
+export type Endpoint26_2Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.query"]>>
+export type WebsearchQueryOperation<E = never> = (input: Endpoint26_2Input) => Effect.Effect<Endpoint26_2Output, E>
+
+export interface WebsearchApi<E = never> {
+  readonly provider: {
+    readonly get: WebsearchProviderGetOperation<E>
+    readonly select: WebsearchProviderSelectOperation<E>
+  }
+  readonly query: WebsearchQueryOperation<E>
+}
+
 export interface AppApi<E = never> {
   readonly health: HealthApi<E>
   readonly location: LocationApi<E>
@@ -950,4 +984,5 @@ export interface AppApi<E = never> {
   readonly projectCopy: ProjectCopyApi<E>
   readonly vcs: VcsApi<E>
   readonly debug: DebugApi<E>
+  readonly websearch: WebsearchApi<E>
 }

packages/client/src/effect/generated/client.ts

@@ -1099,6 +1099,39 @@ const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
   location: { list: Endpoint25_0(raw), evict: Endpoint25_1(raw) },
 })
 
+type Endpoint26_0Request = Parameters<RawClient["server.websearch"]["websearch.provider.get"]>[0]
+type Endpoint26_0Input = { readonly location?: Endpoint26_0Request["query"]["location"] }
+const Endpoint26_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint26_0Input) =>
+  raw["websearch.provider.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint26_1Request = Parameters<RawClient["server.websearch"]["websearch.provider.select"]>[0]
+type Endpoint26_1Input = {
+  readonly location?: Endpoint26_1Request["query"]["location"]
+  readonly providerID: Endpoint26_1Request["payload"]["providerID"]
+}
+const Endpoint26_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint26_1Input) =>
+  raw["websearch.provider.select"]({
+    query: { location: input["location"] },
+    payload: { providerID: input["providerID"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+type Endpoint26_2Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
+type Endpoint26_2Input = {
+  readonly location?: Endpoint26_2Request["query"]["location"]
+  readonly query: Endpoint26_2Request["payload"]["query"]
+  readonly providerID?: Endpoint26_2Request["payload"]["providerID"]
+}
+const Endpoint26_2 = (raw: RawClient["server.websearch"]) => (input: Endpoint26_2Input) =>
+  raw["websearch.query"]({
+    query: { location: input["location"] },
+    payload: { query: input["query"], providerID: input["providerID"] },
+  }).pipe(Effect.mapError(mapClientError))
+
+const adaptGroup26 = (raw: RawClient["server.websearch"]) => ({
+  provider: { get: Endpoint26_0(raw), select: Endpoint26_1(raw) },
+  query: Endpoint26_2(raw),
+})
+
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
   location: adaptGroup1(raw["server.location"]),
@@ -1126,6 +1159,7 @@ const adaptClient = (raw: RawClient) => ({
   projectCopy: adaptGroup23(raw["server.projectCopy"]),
   vcs: adaptGroup24(raw["server.vcs"]),
   debug: adaptGroup25(raw["server.debug"]),
+  websearch: adaptGroup26(raw["server.websearch"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/effect/index.ts

@@ -14,6 +14,7 @@ export type {
   PluginApi,
   ProviderApi,
   ReferenceApi,
+  WebSearchApi,
   SessionApi,
   SkillApi,
 } from "./api.js"
@@ -36,6 +37,7 @@ export { Provider } from "@opencode-ai/schema/provider"
 export { Pty } from "@opencode-ai/schema/pty"
 export { Question } from "@opencode-ai/schema/question"
 export { Reference } from "@opencode-ai/schema/reference"
+export { WebSearch } from "@opencode-ai/schema/websearch"
 export { AbsolutePath, RelativePath } from "@opencode-ai/schema/schema"
 export { Session } from "@opencode-ai/schema/session"
 export { SessionInput } from "@opencode-ai/schema/session-input"

packages/client/src/promise/api.ts

@@ -7,6 +7,7 @@ import type {
   PluginApi as EffectPluginApi,
   ProviderApi as EffectProviderApi,
   ReferenceApi as EffectReferenceApi,
+  WebsearchApi,
   SessionApi as EffectSessionApi,
   SkillApi as EffectSkillApi,
 } from "../effect/api/api.js"
@@ -36,6 +37,7 @@ export type ModelApi = PromisifyApi<EffectModelApi<unknown>>
 export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
 export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
 export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
+export type WebSearchApi = PromisifyApi<WebsearchApi<unknown>>
 export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
 export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>
 

packages/client/src/promise/generated/client.ts

@@ -184,6 +184,12 @@ import type {
   DebugLocationListOutput,
   DebugLocationEvictInput,
   DebugLocationEvictOutput,
+  WebsearchProviderGetInput,
+  WebsearchProviderGetOutput,
+  WebsearchProviderSelectInput,
+  WebsearchProviderSelectOutput,
+  WebsearchQueryInput,
+  WebsearchQueryOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -1560,6 +1566,48 @@ export function make(options: ClientOptions) {
           ),
       },
     },
+    websearch: {
+      provider: {
+        get: (input?: WebsearchProviderGetInput, requestOptions?: RequestOptions) =>
+          request<WebsearchProviderGetOutput>(
+            {
+              method: "GET",
+              path: `/api/websearch/provider`,
+              query: { location: input?.["location"] },
+              successStatus: 200,
+              declaredStatuses: [401, 400],
+              empty: false,
+            },
+            requestOptions,
+          ),
+        select: (input: WebsearchProviderSelectInput, requestOptions?: RequestOptions) =>
+          request<WebsearchProviderSelectOutput>(
+            {
+              method: "POST",
+              path: `/api/websearch/provider`,
+              query: { location: input["location"] },
+              body: { providerID: input["providerID"] },
+              successStatus: 204,
+              declaredStatuses: [400, 503, 401],
+              empty: true,
+            },
+            requestOptions,
+          ),
+      },
+      query: (input: WebsearchQueryInput, requestOptions?: RequestOptions) =>
+        request<WebsearchQueryOutput>(
+          {
+            method: "POST",
+            path: `/api/websearch`,
+            query: { location: input["location"] },
+            body: { query: input["query"], providerID: input["providerID"] },
+            successStatus: 200,
+            declaredStatuses: [400, 503, 401],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
   }
 }
 

packages/client/src/promise/generated/types.ts

@@ -2306,6 +2306,7 @@ export type IntegrationListOutput = {
       | { readonly type: "key"; readonly label?: string }
       | { readonly type: "env"; readonly names: ReadonlyArray<string> }
     >
+    readonly websearch?: { readonly connection: "optional" | "required" }
     readonly connections: ReadonlyArray<
       | { readonly type: "credential"; readonly id: string; readonly label: string }
       | { readonly type: "env"; readonly name: string }
@@ -2358,6 +2359,7 @@ export type IntegrationGetOutput = {
       | { readonly type: "key"; readonly label?: string }
       | { readonly type: "env"; readonly names: ReadonlyArray<string> }
     >
+    readonly websearch?: { readonly connection: "optional" | "required" }
     readonly connections: ReadonlyArray<
       | { readonly type: "credential"; readonly id: string; readonly label: string }
       | { readonly type: "env"; readonly name: string }
@@ -2700,6 +2702,14 @@ export type FormRequestListOutput = {
         readonly mode: "url"
         readonly url: string
       }
+    | {
+        readonly id: string
+        readonly sessionID: string
+        readonly title?: string
+        readonly metadata?: { readonly [x: string]: JsonValue }
+        readonly mode: "integration"
+        readonly integrationID: string
+      }
   >
 }
 
@@ -2812,6 +2822,14 @@ export type FormListOutput = {
         readonly mode: "url"
         readonly url: string
       }
+    | {
+        readonly id: string
+        readonly sessionID: string
+        readonly title?: string
+        readonly metadata?: { readonly [x: string]: JsonValue }
+        readonly mode: "integration"
+        readonly integrationID: string
+      }
   >
 }["data"]
 
@@ -3508,6 +3526,14 @@ export type FormCreateOutput = {
         readonly mode: "url"
         readonly url: string
       }
+    | {
+        readonly id: string
+        readonly sessionID: string
+        readonly title?: string
+        readonly metadata?: { readonly [x: string]: JsonValue }
+        readonly mode: "integration"
+        readonly integrationID: string
+      }
 }["data"]
 
 export type FormGetInput = {
@@ -3622,6 +3648,14 @@ export type FormGetOutput = {
         readonly mode: "url"
         readonly url: string
       }
+    | {
+        readonly id: string
+        readonly sessionID: string
+        readonly title?: string
+        readonly metadata?: { readonly [x: string]: JsonValue }
+        readonly mode: "integration"
+        readonly integrationID: string
+      }
 }["data"]
 
 export type FormStateInput = {
@@ -5441,6 +5475,14 @@ export type EventSubscribeOutput =
               readonly mode: "url"
               readonly url: string
             }
+          | {
+              readonly id: string
+              readonly sessionID: string
+              readonly title?: string
+              readonly metadata?: { readonly [x: string]: unknown }
+              readonly mode: "integration"
+              readonly integrationID: string
+            }
       }
     }
   | {
@@ -6236,3 +6278,44 @@ export type DebugLocationEvictInput = {
 }
 
 export type DebugLocationEvictOutput = void
+
+export type WebsearchProviderGetInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+}
+
+export type WebsearchProviderGetOutput = {
+  readonly location: {
+    readonly directory: string
+    readonly workspaceID?: string
+    readonly project: { readonly id: string; readonly directory: string }
+  }
+  readonly data: string | null
+}
+
+export type WebsearchProviderSelectInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+  readonly providerID: { readonly providerID: string }["providerID"]
+}
+
+export type WebsearchProviderSelectOutput = void
+
+export type WebsearchQueryInput = {
+  readonly location?: {
+    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  }["location"]
+  readonly query: { readonly query: string; readonly providerID?: string }["query"]
+  readonly providerID?: { readonly query: string; readonly providerID?: string }["providerID"]
+}
+
+export type WebsearchQueryOutput = {
+  readonly location: {
+    readonly directory: string
+    readonly workspaceID?: string
+    readonly project: { readonly id: string; readonly directory: string }
+  }
+  readonly data: { readonly providerID: string; readonly text: string; readonly metadata?: JsonValue }
+}

packages/client/src/promise/index.ts

@@ -9,6 +9,7 @@ export type {
   PluginApi,
   ProviderApi,
   ReferenceApi,
+  WebSearchApi,
   SessionApi,
   SkillApi,
 } from "./api.js"

packages/client/test/promise.test.ts

@@ -31,6 +31,7 @@ test("exposes every standard HTTP API group", () => {
     "projectCopy",
     "vcs",
     "debug",
+    "websearch",
   ])
   expect(Object.keys(client.debug)).toEqual(["location"])
   expect(Object.keys(client.debug.location)).toEqual(["list", "evict"])
@@ -38,6 +39,8 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.integration)).toEqual(["list", "get", "connect", "attempt"])
   expect(Object.keys(client.integration.connect)).toEqual(["key", "oauth"])
   expect(Object.keys(client.integration.attempt)).toEqual(["status", "complete", "cancel"])
+  expect(Object.keys(client.websearch)).toEqual(["provider", "query"])
+  expect(Object.keys(client.websearch.provider)).toEqual(["get", "select"])
   expect(Object.keys(client.file)).toEqual(["read", "list", "find"])
   expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
@@ -45,6 +48,56 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
 })
 
+test("websearch.query uses the public HTTP contract", async () => {
+  let request: Request | undefined
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      request = input instanceof Request ? input : new Request(input, init)
+      return Response.json({
+        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
+        data: { providerID: "exa", text: "result", metadata: { requestID: "req_test" } },
+      })
+    },
+  })
+
+  const result = await client.websearch.query({
+    query: "opencode",
+    providerID: "exa",
+    location: { directory: "/tmp/project" },
+  })
+
+  expect(result.data).toEqual({ providerID: "exa", text: "result", metadata: { requestID: "req_test" } })
+  expect(request?.method).toBe("POST")
+  expect(request?.url).toBe("http://localhost:3000/api/websearch?location%5Bdirectory%5D=%2Ftmp%2Fproject")
+  expect(await request?.json()).toEqual({ query: "opencode", providerID: "exa" })
+})
+
+test("websearch provider methods use the public HTTP contract", async () => {
+  const requests: Request[] = []
+  const client = OpenCode.make({
+    baseUrl: "http://localhost:3000",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      requests.push(request)
+      if (request.method === "POST") return new Response(null, { status: 204 })
+      return Response.json({
+        location: { directory: "/tmp/project", project: { id: "proj_test", directory: "/tmp/project" } },
+        data: "exa",
+      })
+    },
+  })
+
+  expect(await client.websearch.provider.get({ location: { directory: "/tmp/project" } })).toMatchObject({ data: "exa" })
+  await client.websearch.provider.select({ providerID: "parallel", location: { directory: "/tmp/project" } })
+
+  expect(requests.map((request) => [request.method, request.url])).toEqual([
+    ["GET", "http://localhost:3000/api/websearch/provider?location%5Bdirectory%5D=%2Ftmp%2Fproject"],
+    ["POST", "http://localhost:3000/api/websearch/provider?location%5Bdirectory%5D=%2Ftmp%2Fproject"],
+  ])
+  expect(await requests[1]?.json()).toEqual({ providerID: "parallel" })
+})
+
 test("MCP resource catalog uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/core/src/config.ts

@@ -1,4 +1,5 @@
 export * as Config from "./config"
+export * as ConfigGlobal from "./config/global"
 
 import { makeLocationNode } from "./effect/app-node"
 import path from "path"
@@ -23,6 +24,7 @@ import { ConfigModel } from "./config/model"
 import { ConfigPlugin } from "./config/plugin"
 import { ConfigProvider } from "./config/provider"
 import { ConfigReference } from "./config/reference"
+import { ConfigWebSearch } from "./config/websearch"
 import { ConfigToolOutput } from "./config/tool-output"
 import { ConfigVariable } from "./config/variable"
 import { ConfigWatcher } from "./config/watcher"
@@ -102,6 +104,9 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   references: ConfigReference.Info.pipe(Schema.optional).annotate({
     description: "Named local directories or Git repositories available as external context",
   }),
+  websearch: ConfigWebSearch.Info.pipe(Schema.optional).annotate({
+    description: "Web search provider selection",
+  }),
   plugins: ConfigPlugin.Plugins.pipe(Schema.optional).annotate({
     description: "Ordered plugin enablement directives and external package declarations",
   }),

packages/core/src/config/global.ts

@@ -0,0 +1,50 @@
+export * as ConfigGlobal from "./global"
+
+import { randomUUID } from "node:crypto"
+import path from "node:path"
+import { Context, Effect, Layer } from "effect"
+import { applyEdits, modify, type JSONPath } from "jsonc-parser"
+import { makeGlobalNode } from "../effect/app-node"
+import { FSUtil } from "../fs-util"
+import { Global } from "../global"
+import { EffectFlock } from "../util/effect-flock"
+
+export interface Interface {
+  readonly update: (path: JSONPath, value: unknown) => Effect.Effect<void, FSUtil.Error | EffectFlock.LockError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/ConfigGlobal") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const global = yield* Global.Service
+    const flock = yield* EffectFlock.Service
+
+    return Service.of({
+      update: Effect.fn("ConfigGlobal.update")(function* (jsonPath, value) {
+        yield* flock.withLock(
+          Effect.gen(function* () {
+            const existing = yield* Effect.filter(
+              ["opencode.jsonc", "opencode.json"].map((name) => path.join(global.config, name)),
+              fs.existsSafe,
+            )
+            const filepath = existing[0] ?? path.join(global.config, "opencode.json")
+            const text = (yield* fs.readFileStringSafe(filepath)) ?? "{}"
+            const next = applyEdits(
+              text,
+              modify(text, jsonPath, value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
+            )
+            const temp = `${filepath}.${randomUUID()}.tmp`
+            yield* fs.writeWithDirs(temp, next)
+            yield* fs.rename(temp, filepath).pipe(Effect.ensuring(fs.remove(temp).pipe(Effect.ignore)))
+          }),
+          "global-config",
+        )
+      }),
+    })
+  }),
+)
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [EffectFlock.node, FSUtil.node, Global.node] })

packages/core/src/config/websearch.ts

@@ -0,0 +1,8 @@
+export * as ConfigWebSearch from "./websearch"
+
+import { Integration } from "@opencode-ai/schema/integration"
+import { Schema } from "effect"
+
+export class Info extends Schema.Class<Info>("ConfigWebSearch.Info")({
+  provider: Integration.ID,
+}) {}

packages/core/src/form.ts

@@ -67,6 +67,7 @@ export class InvalidFormError extends Schema.TaggedErrorClass<InvalidFormError>(
 export type CreateInput =
   | (Omit<Form.FormInfo, "id"> & { readonly id?: ID })
   | (Omit<Form.UrlInfo, "id"> & { readonly id?: ID })
+  | (Omit<Form.IntegrationInfo, "id"> & { readonly id?: ID })
 
 export interface ReplyInput {
   readonly id: ID
@@ -138,7 +139,9 @@ export const layer = Layer.effect(
           const form: Info =
             input.mode === "form"
               ? { ...base, mode: "form", fields: input.fields }
-              : { ...base, mode: "url", url: input.url }
+              : input.mode === "url"
+                ? { ...base, mode: "url", url: input.url }
+                : { ...base, mode: "integration", integrationID: input.integrationID }
           const entry: Entry = {
             form,
             state: { status: "pending" },
@@ -228,9 +231,9 @@ export const locationLayer = layer
 export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node] })
 
 function validateAnswer(form: Info, answer: Answer) {
-  if (form.mode === "url") {
+  if (form.mode !== "form") {
     if (Object.keys(answer).length === 0) return
-    return "URL forms must be answered with an empty answer"
+    return `${form.mode === "url" ? "URL" : "Integration"} forms must be answered with an empty answer`
   }
   const fields = new Map(form.fields.map((field) => [field.key, field]))
   for (const key of Object.keys(answer)) {

packages/core/src/integration.ts

@@ -16,6 +16,7 @@ import {
   Types,
 } from "effect"
 import { Integration } from "@opencode-ai/schema/integration"
+import { WebSearch } from "@opencode-ai/schema/websearch"
 import { Credential } from "./credential"
 import { State } from "./state"
 import { EventV2 } from "./event"
@@ -94,6 +95,15 @@ export interface EnvImplementation {
 
 export type Implementation = OAuthImplementation | KeyImplementation | EnvImplementation
 
+export interface WebSearchImplementation {
+  readonly integrationID: ID
+  readonly connection: Integration.WebSearch["connection"]
+  readonly execute: (
+    input: WebSearch.Input,
+    context: { readonly credential?: Credential.Value; readonly sessionID?: string },
+  ) => Effect.Effect<WebSearch.ProviderOutput, unknown>
+}
+
 export const Attempt = Integration.Attempt
 export type Attempt = Integration.Attempt
 
@@ -119,6 +129,7 @@ type Entry = {
   ref: Types.DeepMutable<Ref>
   methods: Types.DeepMutable<Method>[]
   implementations: Map<MethodID, Types.DeepMutable<OAuthImplementation>>
+  websearch?: Types.DeepMutable<WebSearchImplementation>
 }
 
 type Data = {
@@ -135,6 +146,11 @@ export type Draft = {
     update: (implementation: Implementation) => void
     remove: (integrationID: ID, method: Method) => void
   }
+  websearch: {
+    list: () => readonly WebSearchImplementation[]
+    update: (implementation: WebSearchImplementation) => void
+    remove: (integrationID: ID) => void
+  }
 }
 
 export interface Interface extends State.Transformable<Draft> {
@@ -191,6 +207,10 @@ export interface Interface extends State.Transformable<Draft> {
     /** Cancels an attempt and releases its resources. */
     readonly cancel: (attemptID: AttemptID) => Effect.Effect<void>
   }
+  readonly websearch: {
+    readonly list: () => Effect.Effect<readonly WebSearchImplementation[]>
+    readonly get: (integrationID: ID) => Effect.Effect<WebSearchImplementation | undefined>
+  }
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Integration") {}
@@ -281,6 +301,30 @@ const layer = Layer.effect(
             if (method.type === "oauth") current.implementations.delete(method.id)
           },
         },
+        websearch: {
+          list: () =>
+            Array.from(draft.integrations.values()).flatMap((entry) =>
+              entry.websearch ? [entry.websearch as WebSearchImplementation] : [],
+            ),
+          update: (implementation) => {
+            const current = draft.integrations.get(implementation.integrationID) ?? {
+              ref: {
+                id: implementation.integrationID,
+                name: implementation.integrationID,
+              },
+              methods: [],
+              implementations: new Map<MethodID, Types.DeepMutable<OAuthImplementation>>(),
+            }
+            if (!draft.integrations.has(implementation.integrationID)) {
+              draft.integrations.set(implementation.integrationID, current)
+            }
+            current.websearch = implementation as Types.DeepMutable<WebSearchImplementation>
+          },
+          remove: (integrationID) => {
+            const current = draft.integrations.get(integrationID)
+            if (current) delete current.websearch
+          },
+        },
       }),
       finalize: () => events.publish(Event.Updated, {}).pipe(Effect.asVoid),
     })
@@ -305,6 +349,7 @@ const layer = Layer.effect(
         id: entry.ref.id,
         name: entry.ref.name,
         methods: entry.methods,
+        websearch: entry.websearch ? { connection: entry.websearch.connection } : undefined,
         connections,
       })
 
@@ -514,6 +559,16 @@ const layer = Layer.effect(
           if (attempt) yield* Scope.close(attempt.scope, Exit.void)
         }),
       },
+      websearch: {
+        list: Effect.fn("Integration.websearch.list")(function* () {
+          return Array.from(state.get().integrations.values()).flatMap((entry) =>
+            entry.websearch ? [entry.websearch as WebSearchImplementation] : [],
+          )
+        }),
+        get: Effect.fn("Integration.websearch.get")(function* (integrationID) {
+          return state.get().integrations.get(integrationID)?.websearch as WebSearchImplementation | undefined
+        }),
+      },
     })
   }),
 )

packages/core/src/location-services.ts

@@ -34,6 +34,7 @@ import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
 import { Shell } from "./shell"
 import { Reference } from "./reference"
+import { WebSearch } from "./websearch"
 import { ReferenceGuidance } from "./reference/guidance"
 import { Ripgrep } from "./ripgrep"
 import { SessionRunnerLLM } from "./session/runner/llm"
@@ -51,7 +52,6 @@ import { SessionInstructions } from "./session/instructions"
 import { McpTool } from "./tool/mcp"
 import { ReadToolFileSystem } from "./tool/read-filesystem"
 import { ToolRegistry } from "./tool/registry"
-import { WebSearchTool } from "./tool/websearch"
 import { ToolOutputStore } from "./tool-output-store"
 import { Vcs } from "./vcs"
 
@@ -84,13 +84,13 @@ const pluginSupervisorNode = makeLocationNode({
     Form.node,
     ReadToolFileSystem.node,
     Reference.node,
+    WebSearch.node,
     Ripgrep.node,
     SessionInstructions.node,
     SessionTodo.node,
     Shell.node,
     SkillV2.node,
     ToolRegistry.toolsNode,
-    WebSearchTool.configNode,
   ],
 })
 
@@ -100,6 +100,7 @@ const locationServiceNodes = [
   AgentV2.node,
   CommandV2.node,
   Reference.node,
+  WebSearch.node,
   Integration.node,
   Catalog.node,
   AISDK.node,

packages/core/src/plugin/host.ts

@@ -1,6 +1,8 @@
 export * as PluginHost from "./host"
 
-import type { Plugin } from "@opencode-ai/plugin/v2/effect"
+import { Plugin } from "@opencode-ai/plugin/v2/effect"
+import type { IntegrationDefinition, IntegrationMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
+import type { CredentialOAuth } from "@opencode-ai/sdk/v2/types"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { Effect, Schema, Stream } from "effect"
 import { AgentV2 } from "../agent"
@@ -197,6 +199,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
             connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
           ),
       },
+      register: (definition) => integration.transform((draft) => registerIntegration(draft, definition)),
       transform: (callback) =>
         integration.transform((draft) => {
           callback({
@@ -206,72 +209,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
             remove: (id) => draft.remove(Integration.ID.make(id)),
             method: {
               list: (id) => mutable(draft.method.list(Integration.ID.make(id))),
-              update: (input) => {
-                if ("authorize" in input) {
-                  const methodID = Integration.MethodID.make(input.method.id)
-                  const refresh = input.refresh
-                  draft.method.update({
-                    integrationID: Integration.ID.make(input.integrationID),
-                    method: { ...input.method, id: methodID },
-                    authorize: (inputs) =>
-                      input.authorize(inputs).pipe(
-                        Effect.map((authorization) => {
-                          if (authorization.mode === "auto") {
-                            return {
-                              ...authorization,
-                              callback: authorization.callback.pipe(
-                                Effect.map((credential) =>
-                                  Credential.OAuth.make({
-                                    ...credential,
-                                    methodID: Integration.MethodID.make(credential.methodID),
-                                  }),
-                                ),
-                              ),
-                            }
-                          }
-                          return {
-                            ...authorization,
-                            callback: (code: string) =>
-                              authorization.callback(code).pipe(
-                                Effect.map((credential) =>
-                                  Credential.OAuth.make({
-                                    ...credential,
-                                    methodID: Integration.MethodID.make(credential.methodID),
-                                  }),
-                                ),
-                              ),
-                          }
-                        }),
-                      ),
-                    ...(refresh
-                      ? {
-                          refresh: (value: Credential.OAuth) =>
-                            refresh(value).pipe(
-                              Effect.map((next) =>
-                                Credential.OAuth.make({
-                                  ...next,
-                                  methodID: Integration.MethodID.make(next.methodID),
-                                }),
-                              ),
-                            ),
-                        }
-                      : {}),
-                    ...(input.label ? { label: input.label } : {}),
-                  })
-                  return
-                }
-                if (input.method.type === "env") {
-                  draft.method.update({
-                    integrationID: Integration.ID.make(input.integrationID),
-                    method: { type: "env", names: input.method.names },
-                  })
-                  return
-                }
-                draft.method.update({
-                  integrationID: Integration.ID.make(input.integrationID),
-                  method: { type: "key", label: input.method.label },
-                })
-              },
+              update: (input) => draft.method.update(methodImplementation(input)),
               remove: (id, method) =>
                 draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
             },
@@ -383,3 +321,75 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
     },
   } satisfies Plugin.Context
 })
+
+function registerIntegration(draft: Integration.Draft, definition: IntegrationDefinition) {
+  const integrationID = Integration.ID.make(definition.id)
+  draft.update(integrationID, (integration) => (integration.name = definition.name))
+  for (const method of definition.methods ?? []) {
+    if (method.type === "env") {
+      draft.method.update(methodImplementation({ integrationID: definition.id, method }))
+      continue
+    }
+    if (method.type === "key") {
+      draft.method.update(methodImplementation({ integrationID: definition.id, method }))
+      continue
+    }
+    const { authorize, refresh, credentialLabel, ...info } = method
+    draft.method.update(
+      methodImplementation({
+        integrationID: definition.id,
+        method: info,
+        authorize,
+        ...(refresh ? { refresh } : {}),
+        ...(credentialLabel ? { label: credentialLabel } : {}),
+      }),
+    )
+  }
+  if (!definition.websearch) return
+  draft.websearch.update({
+    integrationID,
+    connection: definition.websearch.connection,
+    execute: definition.websearch.execute,
+  })
+}
+
+function methodImplementation(input: IntegrationMethodRegistration): Integration.Implementation {
+  if ("authorize" in input) {
+    const refresh = input.refresh
+    return {
+      integrationID: Integration.ID.make(input.integrationID),
+      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
+      authorize: (inputs) =>
+        input.authorize(inputs).pipe(
+          Effect.map((authorization) => {
+            if (authorization.mode === "auto") {
+              return {
+                ...authorization,
+                callback: authorization.callback.pipe(Effect.map(credential)),
+              }
+            }
+            return {
+              ...authorization,
+              callback: (code: string) => authorization.callback(code).pipe(Effect.map(credential)),
+            }
+          }),
+        ),
+      ...(refresh ? { refresh: (value: Credential.OAuth) => refresh(value).pipe(Effect.map(credential)) } : {}),
+      ...(input.label ? { label: input.label } : {}),
+    }
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: Integration.ID.make(input.integrationID),
+      method: { type: "env", names: input.method.names },
+    }
+  }
+  return {
+    integrationID: Integration.ID.make(input.integrationID),
+    method: { type: "key", label: input.method.label },
+  }
+}
+
+function credential(value: CredentialOAuth) {
+  return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) })
+}

packages/core/src/plugin/internal.ts

@@ -26,6 +26,7 @@ import { ModelsDev } from "../models-dev"
 import { Npm } from "../npm"
 import { PermissionV2 } from "../permission"
 import { Reference } from "../reference"
+import { WebSearch } from "../websearch"
 import { Ripgrep } from "../ripgrep"
 import { SessionInstructions } from "../session/instructions"
 import { SessionTodo } from "../session/todo"
@@ -50,6 +51,7 @@ import { AgentPlugin } from "./agent"
 import { CommandPlugin } from "./command"
 import { ModelsDevPlugin } from "./models-dev"
 import { ProviderPlugins } from "./provider"
+import { WebSearchPlugins } from "./websearch"
 import { PluginRuntime } from "./runtime"
 import { SkillPlugin } from "./skill"
 import { VariantPlugin } from "./variant"
@@ -76,13 +78,13 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const form = yield* Form.Service
   const read = yield* ReadToolFileSystem.Service
   const reference = yield* Reference.Service
+  const websearch = yield* WebSearch.Service
   const ripgrep = yield* Ripgrep.Service
   const instructions = yield* SessionInstructions.Service
   const todo = yield* SessionTodo.Service
   const shell = yield* Shell.Service
   const skill = yield* SkillV2.Service
   const tools = yield* Tools.Service
-  const websearch = yield* WebSearchTool.ConfigService
   return Context.mergeAll(
     Context.make(AgentV2.Service, agent),
     Context.make(Catalog.Service, catalog),
@@ -105,13 +107,13 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(Form.Service, form),
     Context.make(ReadToolFileSystem.Service, read),
     Context.make(Reference.Service, reference),
+    Context.make(WebSearch.Service, websearch),
     Context.make(Ripgrep.Service, ripgrep),
     Context.make(SessionInstructions.Service, instructions),
     Context.make(SessionTodo.Service, todo),
     Context.make(Shell.Service, shell),
     Context.make(SkillV2.Service, skill),
     Context.make(Tools.Service, tools),
-    Context.make(WebSearchTool.ConfigService, websearch),
   )
 })
 
@@ -127,6 +129,7 @@ const pre = [
   SkillPlugin.Plugin,
   ModelsDevPlugin,
   ...ProviderPlugins,
+  ...WebSearchPlugins,
   PatchTool.Plugin,
   EditTool.Plugin,
   GlobTool.Plugin,

packages/core/src/plugin/promise.ts

@@ -1,6 +1,7 @@
 export * as PluginPromise from "./promise"
 
 import { Plugin } from "@opencode-ai/plugin/v2/effect"
+import type { IntegrationDefinition } from "@opencode-ai/plugin/v2/integration"
 import { Effect, Scope, Stream } from "effect"
 
 type HostRegistration = { readonly dispose: Effect.Effect<void> }
@@ -87,6 +88,7 @@ export function fromPromise(plugin: PromisePlugin) {
               complete: (input) => run(host.integration.attempt.complete(input)),
               cancel: (input) => run(host.integration.attempt.cancel(input)),
             },
+            register: (definition) => register(host.integration.register(adaptIntegration(definition))),
             transform: transform(host.integration),
             reload: () => run(host.integration.reload()),
             connection: {
@@ -127,3 +129,54 @@ export function fromPromise(plugin: PromisePlugin) {
       }),
   })
 }
+
+function adaptIntegration(definition: IntegrationDefinition) {
+  const { methods, websearch, ...definitionInfo } = definition
+  return {
+    ...definitionInfo,
+    methods: methods?.map((method) => {
+      if (method.type !== "oauth") return method
+      const { authorize, refresh, ...methodInfo } = method
+      return {
+        ...methodInfo,
+        authorize: (inputs: Parameters<typeof authorize>[0]) =>
+          Effect.tryPromise({ try: () => authorize(inputs), catch: (cause) => cause }).pipe(
+            Effect.map((authorization) => {
+              if (authorization.mode === "auto") {
+                return {
+                  ...authorization,
+                  callback: Effect.tryPromise({ try: () => authorization.callback, catch: (cause) => cause }),
+                }
+              }
+              return {
+                ...authorization,
+                callback: (code: string) =>
+                  Effect.tryPromise({ try: () => authorization.callback(code), catch: (cause) => cause }),
+              }
+            }),
+          ),
+        ...(refresh
+          ? {
+              refresh: (credential: Parameters<typeof refresh>[0]) =>
+                Effect.tryPromise({ try: () => refresh(credential), catch: (cause) => cause }),
+            }
+          : {}),
+      }
+    }),
+    ...(websearch
+      ? {
+          websearch: {
+            connection: websearch.connection,
+            execute: (
+              input: Parameters<typeof websearch.execute>[0],
+              execution: Omit<Parameters<typeof websearch.execute>[1], "signal">,
+            ) =>
+              Effect.tryPromise({
+                try: (signal) => websearch.execute(input, { ...execution, signal }),
+                catch: (cause) => cause,
+              }),
+          },
+        }
+      : {}),
+  }
+}

packages/core/src/plugin/websearch/exa.ts

@@ -0,0 +1,60 @@
+export * as WebSearchExa from "./exa"
+
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { Effect, Schema, Scope } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import { WebSearchMcp } from "./mcp"
+
+export const endpoint = "https://mcp.exa.ai/mcp"
+
+const Input = Schema.Struct({
+  query: Schema.String,
+  numResults: Schema.Number.pipe(Schema.optional),
+})
+
+const Output = Schema.Struct({
+  content: Schema.Array(
+    Schema.Struct({
+      type: Schema.Literal("text"),
+      text: Schema.String,
+      _meta: Schema.Struct({ searchTime: Schema.Number }).pipe(Schema.optional),
+    }),
+  ),
+})
+
+export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
+  id: "opencode.websearch.exa",
+  effect: Effect.fn("WebSearchExa.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient
+    yield* ctx.integration.register({
+      id: "exa",
+      name: "Exa",
+      methods: [
+        { type: "key", label: "API key (optional)" },
+        { type: "env", names: ["EXA_API_KEY"] },
+      ],
+      websearch: {
+        connection: "optional",
+        execute: (input, context) => {
+          const url = new URL(endpoint)
+          if (context.credential?.type === "key") url.searchParams.set("exaApiKey", context.credential.key)
+          return WebSearchMcp.call(
+            http,
+            url.toString(),
+            "web_search_exa",
+            { input: Input, output: Output },
+            { query: input.query, numResults: 8 },
+          ).pipe(
+            Effect.map((result) => {
+              const content = result?.content.find((item) => item.text)
+              return {
+                text: content?.text ?? "",
+                ...(content?._meta ? { metadata: content._meta } : {}),
+              }
+            }),
+          )
+        },
+      },
+    })
+  }),
+})

packages/core/src/plugin/websearch/index.ts

@@ -0,0 +1,4 @@
+import { WebSearchExa } from "./exa"
+import { WebSearchParallel } from "./parallel"
+
+export const WebSearchPlugins = [WebSearchExa.Plugin, WebSearchParallel.Plugin] as const

packages/core/src/plugin/websearch/mcp.ts

@@ -0,0 +1,69 @@
+export * as WebSearchMcp from "./mcp"
+
+import { Duration, Effect, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { collectBoundedResponseBody } from "../../tool/http-body"
+
+export const MAX_RESPONSE_BYTES = 256 * 1024
+
+export const parseResponse = <F extends Schema.Struct.Fields>(body: string, result: Schema.Struct<F>) => {
+  const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ result })))
+  const parse = (payload: string) => {
+    const trimmed = payload.trim()
+    if (!trimmed.startsWith("{")) return Effect.succeed(undefined)
+    return decode(trimmed).pipe(Effect.map((response) => response.result))
+  }
+  return Effect.gen(function* () {
+    const trimmed = body.trim()
+    const direct = trimmed ? yield* parse(trimmed) : undefined
+    if (direct) return direct
+    for (const line of body.split("\n")) {
+      if (!line.startsWith("data: ")) continue
+      const data = yield* parse(line.substring(6))
+      if (data) return data
+    }
+  })
+}
+
+const Request = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
+  Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({ name: Schema.String, arguments: args }),
+  })
+
+export const call = <F extends Schema.Struct.Fields, R extends Schema.Struct.Fields>(
+  http: HttpClient.HttpClient,
+  url: string,
+  tool: string,
+  schema: { readonly input: Schema.Struct<F>; readonly output: Schema.Struct<R> },
+  value: Schema.Struct.Type<F>,
+  headers: Record<string, string> = {},
+) =>
+  Effect.gen(function* () {
+    const request = yield* HttpClientRequest.post(url).pipe(
+      HttpClientRequest.accept("application/json, text/event-stream"),
+      HttpClientRequest.setHeaders(headers),
+      HttpClientRequest.schemaBodyJson(Request(schema.input))({
+        jsonrpc: "2.0" as const,
+        id: 1 as const,
+        method: "tools/call" as const,
+        params: { name: tool, arguments: value },
+      }),
+    )
+    return yield* Effect.gen(function* () {
+      const response = yield* HttpClient.filterStatusOk(http).execute(request)
+      const body = yield* collectBoundedResponseBody(
+        response,
+        MAX_RESPONSE_BYTES,
+        () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`),
+      )
+      return yield* parseResponse(body.toString("utf8"), schema.output)
+    }).pipe(
+      Effect.timeoutOrElse({
+        duration: Duration.seconds(25),
+        orElse: () => Effect.fail(new Error(`${tool} request timed out`)),
+      }),
+    )
+  })

packages/core/src/plugin/websearch/parallel.ts

@@ -0,0 +1,92 @@
+export * as WebSearchParallel from "./parallel"
+
+import { define } from "@opencode-ai/plugin/v2/effect/plugin"
+import { Effect, Schema, Scope } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import { InstallationVersion } from "../../installation/version"
+import { WebSearchMcp } from "./mcp"
+
+export const endpoint = "https://search.parallel.ai/mcp"
+
+const Input = Schema.Struct({
+  objective: Schema.String,
+  search_queries: Schema.Array(Schema.String),
+  session_id: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional),
+  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional),
+})
+
+const Metadata = Schema.Struct({
+  search_id: Schema.String,
+  results: Schema.Array(
+    Schema.Struct({
+      url: Schema.String,
+      title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+      publish_date: Schema.NullOr(Schema.String).pipe(Schema.optional),
+      excerpts: Schema.Array(Schema.String),
+    }),
+  ),
+  warnings: Schema.NullOr(
+    Schema.Array(
+      Schema.Struct({
+        type: Schema.Literals(["spec_validation_warning", "input_validation_warning", "warning"]),
+        message: Schema.String,
+        detail: Schema.NullOr(Schema.Record(Schema.String, Schema.Json)).pipe(Schema.optional),
+      }),
+    ),
+  ).pipe(Schema.optional),
+  usage: Schema.NullOr(
+    Schema.Array(
+      Schema.Struct({
+        name: Schema.String,
+        count: Schema.Int,
+      }),
+    ),
+  ).pipe(Schema.optional),
+  session_id: Schema.String,
+})
+const Output = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
+  structuredContent: Metadata,
+})
+
+export const Plugin = define<HttpClient.HttpClient | Scope.Scope>({
+  id: "opencode.websearch.parallel",
+  effect: Effect.fn("WebSearchParallel.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient
+    yield* ctx.integration.register({
+      id: "parallel",
+      name: "Parallel",
+      methods: [
+        { type: "key", label: "API key (optional)" },
+        { type: "env", names: ["PARALLEL_API_KEY"] },
+      ],
+      websearch: {
+        connection: "optional",
+        execute: (input, context) =>
+          WebSearchMcp.call(
+            http,
+            endpoint,
+            "web_search",
+            { input: Input, output: Output },
+            {
+              objective: input.query,
+              search_queries: [input.query],
+              ...(context.sessionID ? { session_id: context.sessionID } : {}),
+            },
+            {
+              "User-Agent": `opencode/${InstallationVersion}`,
+              ...(context.credential?.type === "key" ? { Authorization: `Bearer ${context.credential.key}` } : {}),
+            },
+          ).pipe(
+            Effect.map((result) => {
+              const content = result?.content.find((item) => item.text)
+              return {
+                text: content?.text ?? "",
+                ...(result ? { metadata: result.structuredContent } : {}),
+              }
+            }),
+          ),
+      },
+    })
+  }),
+})

packages/core/src/tool/websearch.ts

@@ -2,197 +2,34 @@ export * as WebSearchTool from "./websearch"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { ToolFailure } from "@opencode-ai/llm"
-import { Context, Duration, Effect, Layer, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-import { makeLocationNode } from "../effect/app-node"
-import { truthy } from "../flag/flag"
-import { InstallationVersion } from "../installation/version"
-import { PositiveInt } from "../schema"
+import { Effect, Schema } from "effect"
+import { Integration } from "../integration"
 import { PermissionV2 } from "../permission"
+import { WebSearch } from "../websearch"
 import { Tool } from "./tool"
-import { collectBoundedResponseBody } from "./http-body"
-import { checksum } from "../util/encode"
 
 export const name = "websearch"
 export const NO_RESULTS = "No search results found. Please try a different query."
-export const EXA_URL = "https://mcp.exa.ai/mcp"
-export const PARALLEL_URL = "https://search.parallel.ai/mcp"
-export const MAX_NUM_RESULTS = 20
-export const MAX_CONTEXT_CHARACTERS = 50_000
-export const MAX_RESPONSE_BYTES = 256 * 1024
 
-/**
- * Provider-independent local web search retained in V2 core for launch parity.
- * This invokes the legacy Exa/Parallel product backends itself. It is distinct
- * from provider-hosted web search tools, which remain route-owned and execute
- * at the model provider. Ownership of this compromise can be revisited later.
- */
-export const description = `Search the web using the session's local web search provider. Use this for current information beyond knowledge cutoff.
-
-This is a provider-independent local tool backed by Exa or Parallel. Provider-hosted web search tools are separate and execute at the model provider.
-
-Optional controls support result count, live crawling ('fallback' or 'preferred'), search type ('auto', 'fast', or 'deep'), and maximum context characters.
+export const description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
 
 The current year is ${new Date().getFullYear()}. Use this year when searching for recent information or current events.`
 
 export const Input = Schema.Struct({
   query: Schema.String.annotate({ description: "Websearch query" }),
-  numResults: Schema.optional(PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_NUM_RESULTS))).annotate({
-    description: `Number of search results to return (default: 8, maximum: ${MAX_NUM_RESULTS})`,
-  }),
-  livecrawl: Schema.optional(Schema.Literals(["fallback", "preferred"])).annotate({
-    description:
-      "Live crawl mode - 'fallback': use live crawling as backup if cached unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
-  }),
-  type: Schema.optional(Schema.Literals(["auto", "fast", "deep"])).annotate({
-    description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search",
-  }),
-  contextMaxCharacters: Schema.optional(PositiveInt.check(Schema.isLessThanOrEqualTo(MAX_CONTEXT_CHARACTERS))).annotate(
-    {
-      description: `Maximum characters for context string optimized for models (default: 10000, maximum: ${MAX_CONTEXT_CHARACTERS})`,
-    },
-  ),
 })
 
-export const Provider = Schema.Literals(["exa", "parallel"])
-export type Provider = typeof Provider.Type
-
-export interface Config {
-  readonly provider?: Provider
-  readonly enableExa: boolean
-  readonly enableParallel: boolean
-  readonly exaApiKey?: string
-  readonly parallelApiKey?: string
-}
-
-export class ConfigService extends Context.Service<ConfigService, Config>()("@opencode/v2/WebSearchConfig") {}
-
-/** Isolates the retained product environment contract from the generic tool implementation. */
-export const defaultConfigLayer = Layer.sync(ConfigService, () =>
-  ConfigService.of({
-    provider:
-      process.env.OPENCODE_WEBSEARCH_PROVIDER === "exa" || process.env.OPENCODE_WEBSEARCH_PROVIDER === "parallel"
-        ? process.env.OPENCODE_WEBSEARCH_PROVIDER
-        : undefined,
-    enableExa: truthy("OPENCODE_EXPERIMENTAL") || truthy("OPENCODE_ENABLE_EXA") || truthy("OPENCODE_EXPERIMENTAL_EXA"),
-    enableParallel: truthy("OPENCODE_ENABLE_PARALLEL") || truthy("OPENCODE_EXPERIMENTAL_PARALLEL"),
-    exaApiKey: process.env.EXA_API_KEY,
-    parallelApiKey: process.env.PARALLEL_API_KEY,
-  }),
-)
-
-export const configNode = makeLocationNode({ service: ConfigService, layer: defaultConfigLayer, deps: [] })
-
-export function selectProvider(
-  sessionID: string,
-  flags: Pick<Config, "enableExa" | "enableParallel"> = { enableExa: false, enableParallel: false },
-  override?: Provider,
-): Provider {
-  if (override) return override
-  if (flags.enableParallel) return "parallel"
-  if (flags.enableExa) return "exa"
-  return Number.parseInt(checksum(sessionID) ?? "0", 36) % 2 === 0 ? "exa" : "parallel"
-}
-
-const McpResult = Schema.Struct({
-  result: Schema.Struct({
-    content: Schema.Array(Schema.Struct({ type: Schema.String, text: Schema.String })),
-  }),
-})
-const decodeMcpResult = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
-
-const parsePayload = (payload: string) =>
-  Effect.gen(function* () {
-    const trimmed = payload.trim()
-    if (!trimmed.startsWith("{")) return undefined
-    return (yield* decodeMcpResult(trimmed)).result.content.find((item) => item.text)?.text
-  })
-
-export const parseResponse = Effect.fn("WebSearchTool.parseResponse")(function* (body: string) {
-  const trimmed = body.trim()
-  const direct = trimmed ? yield* parsePayload(trimmed) : undefined
-  if (direct) return direct
-  for (const line of body.split("\n")) {
-    if (!line.startsWith("data: ")) continue
-    const data = yield* parsePayload(line.substring(6))
-    if (data) return data
-  }
-  return undefined
-})
-
-const ExaArgs = Schema.Struct({
-  query: Schema.String,
-  type: Schema.String,
-  numResults: Schema.Number,
-  livecrawl: Schema.String,
-  contextMaxCharacters: Schema.optional(Schema.Number),
-})
-const ParallelArgs = Schema.Struct({
-  objective: Schema.String,
-  search_queries: Schema.Array(Schema.String),
-  session_id: Schema.String,
-})
-const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
-  Schema.Struct({
-    jsonrpc: Schema.Literal("2.0"),
-    id: Schema.Literal(1),
-    method: Schema.Literal("tools/call"),
-    params: Schema.Struct({ name: Schema.String, arguments: args }),
-  })
-
-const exaUrl = (apiKey: string | undefined) => {
-  if (!apiKey) return EXA_URL
-  const url = new URL(EXA_URL)
-  url.searchParams.set("exaApiKey", apiKey)
-  return url.toString()
-}
-
-const callMcp = <F extends Schema.Struct.Fields>(
-  http: HttpClient.HttpClient,
-  url: string,
-  tool: string,
-  args: Schema.Struct<F>,
-  value: Schema.Struct.Type<F>,
-  headers: Record<string, string> = {},
-) =>
-  Effect.gen(function* () {
-    const request = yield* HttpClientRequest.post(url).pipe(
-      HttpClientRequest.accept("application/json, text/event-stream"),
-      HttpClientRequest.setHeaders(headers),
-      HttpClientRequest.schemaBodyJson(McpRequest(args))({
-        jsonrpc: "2.0" as const,
-        id: 1 as const,
-        method: "tools/call" as const,
-        params: { name: tool, arguments: value },
-      }),
-    )
-    return yield* Effect.gen(function* () {
-      const response = yield* HttpClient.filterStatusOk(http).execute(request)
-      const body = yield* collectBoundedResponseBody(
-        response,
-        MAX_RESPONSE_BYTES,
-        () => new Error(`${tool} response exceeded ${MAX_RESPONSE_BYTES} bytes`),
-      )
-      return yield* parseResponse(body.toString("utf8"))
-    }).pipe(
-      Effect.timeoutOrElse({
-        duration: Duration.seconds(25),
-        orElse: () => Effect.fail(new Error(`${tool} request timed out`)),
-      }),
-    )
-  })
-
 const Output = Schema.Struct({
-  provider: Provider,
+  provider: Integration.ID,
   text: Schema.String,
+  metadata: Schema.optional(Schema.Json),
 })
 
 export const Plugin = {
   id: "opencode.tool.websearch",
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
-    const http = yield* HttpClient.HttpClient
-    const config = yield* ConfigService
     const permission = yield* PermissionV2.Service
+    const websearch = yield* WebSearch.Service
 
     yield* ctx.tool
       .transform((draft) =>
@@ -203,54 +40,28 @@ export const Plugin = {
             input: Input,
             output: Output,
             toModelOutput: ({ output }) => [{ type: "text", text: output.text }],
-            execute: (input, context) => {
-              const provider = selectProvider(context.sessionID, config, config.provider)
-              return Effect.gen(function* () {
+            execute: (input, context) =>
+              Effect.gen(function* () {
                 yield* permission.assert({
                   action: name,
                   resources: [input.query],
                   save: ["*"],
-                  metadata: { ...input, provider },
+                  metadata: input,
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source: { type: "tool", messageID: context.assistantMessageID, callID: context.toolCallID },
                 })
-
-                const text =
-                  provider === "exa"
-                    ? yield* callMcp(http, exaUrl(config.exaApiKey), "web_search_exa", ExaArgs, {
-                        query: input.query,
-                        type: input.type || "auto",
-                        numResults: input.numResults || 8,
-                        livecrawl: input.livecrawl || "fallback",
-                        contextMaxCharacters: input.contextMaxCharacters,
-                      })
-                    : yield* callMcp(
-                        http,
-                        PARALLEL_URL,
-                        "web_search",
-                        ParallelArgs,
-                        {
-                          objective: input.query,
-                          search_queries: [input.query],
-                          session_id: context.sessionID,
-                          // V2 invocation context does not safely expose the model yet.
-                        },
-                        {
-                          "User-Agent": `opencode/${InstallationVersion}`,
-                          ...(config.parallelApiKey ? { Authorization: `Bearer ${config.parallelApiKey}` } : {}),
-                        },
-                      )
+                const result = yield* websearch.query({ ...input, sessionID: context.sessionID })
                 return {
-                  provider,
-                  text: text ?? NO_RESULTS,
+                  provider: result.providerID,
+                  text: result.text || NO_RESULTS,
+                  metadata: result.metadata,
                 }
               }).pipe(
                 Effect.mapError(
                   (error) => new ToolFailure({ message: `Unable to search the web for ${input.query}`, error }),
                 ),
-              )
-            },
+              ),
           }),
         ),
       )

packages/core/src/websearch.ts

@@ -0,0 +1,249 @@
+export * as WebSearch from "./websearch"
+
+import { WebSearch } from "@opencode-ai/schema/websearch"
+import { Config as ConfigSchema } from "@opencode-ai/schema/config"
+import { Context, Effect, Layer, Schema, Semaphore, Stream } from "effect"
+import path from "node:path"
+import { Config } from "./config"
+import { ConfigGlobal } from "./config/global"
+import { ConfigWebSearch } from "./config/websearch"
+import { makeLocationNode } from "./effect/app-node"
+import { EventV2 } from "./event"
+import { Form } from "./form"
+import { Global } from "./global"
+import { Integration } from "./integration"
+import { truthy } from "./flag/flag"
+
+export const Input = WebSearch.Input
+export type Input = WebSearch.Input
+
+export const ProviderOutput = WebSearch.ProviderOutput
+export type ProviderOutput = WebSearch.ProviderOutput
+
+export const Result = WebSearch.Result
+export type Result = WebSearch.Result
+
+export class ProviderRequiredError extends Schema.TaggedErrorClass<ProviderRequiredError>()(
+  "WebSearch.ProviderRequired",
+  {},
+) {}
+
+export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()("WebSearch.ProviderNotFound", {
+  providerID: Integration.ID,
+}) {}
+
+export class ConnectionRequiredError extends Schema.TaggedErrorClass<ConnectionRequiredError>()(
+  "WebSearch.ConnectionRequired",
+  { providerID: Integration.ID },
+) {}
+
+export class CancelledError extends Schema.TaggedErrorClass<CancelledError>()("WebSearch.Cancelled", {}) {}
+
+export class RequestError extends Schema.TaggedErrorClass<RequestError>()("WebSearch.Request", {
+  providerID: Integration.ID,
+  cause: Schema.Defect(),
+}) {}
+
+export type Error =
+  | ProviderRequiredError
+  | ProviderNotFoundError
+  | ConnectionRequiredError
+  | CancelledError
+  | RequestError
+
+export interface QueryInput extends Input {
+  readonly sessionID?: string
+}
+
+export interface Interface {
+  readonly selected: () => Effect.Effect<Integration.ID | undefined>
+  readonly select: (providerID: Integration.ID) => Effect.Effect<void, ProviderNotFoundError>
+  readonly query: (input: QueryInput) => Effect.Effect<Result, Error>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/WebSearch") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const config = yield* Config.Service
+    const configGlobal = yield* ConfigGlobal.Service
+    const events = yield* EventV2.Service
+    const forms = yield* Form.Service
+    const global = yield* Global.Service
+    const integrations = yield* Integration.Service
+    const onboarding = Semaphore.makeUnsafe(1)
+    const decodeOutput = Schema.decodeUnknownEffect(ProviderOutput)
+    const globalConfigPath = path.resolve(global.config)
+    let pendingProviderID: Integration.ID | undefined
+
+    const requireProvider = (
+      providers: Map<Integration.ID, Integration.WebSearchImplementation>,
+      providerID: Integration.ID,
+    ) => {
+      const provider = providers.get(providerID)
+      return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }))
+    }
+
+    const globalProviderID = Effect.fn("WebSearch.globalProviderID")(function* () {
+      const entries = (yield* config.entries()).filter(
+        (entry) => entry.type === "document" && entry.path && path.dirname(entry.path) === globalConfigPath,
+      )
+      return Config.latest(entries, "websearch")?.provider
+    })
+
+    const selected = Effect.fn("WebSearch.selected")(function* () {
+      return pendingProviderID ?? (yield* globalProviderID())
+    })
+
+    const saveProvider = Effect.fn("WebSearch.saveProvider")(function* (providerID: Integration.ID) {
+      pendingProviderID = providerID
+      yield* configGlobal.update(["websearch"], new ConfigWebSearch.Info({ provider: providerID })).pipe(
+        Effect.tapError(() => Effect.sync(() => (pendingProviderID = undefined))),
+        Effect.orDie,
+      )
+    })
+
+    yield* events.subscribe(ConfigSchema.Event.Updated).pipe(
+      Stream.runForEach(() =>
+        globalProviderID().pipe(
+          Effect.tap((providerID) =>
+            Effect.sync(() => {
+              if (providerID === pendingProviderID) pendingProviderID = undefined
+            }),
+          ),
+          Effect.ignore,
+        ),
+      ),
+      Effect.forkScoped,
+    )
+
+    const ask = Effect.fn("WebSearch.ask")(function* (
+      providers: Map<Integration.ID, Integration.WebSearchImplementation>,
+      sessionID: string,
+    ) {
+      if (providers.size === 0) return yield* new ProviderRequiredError()
+      const infos = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]))
+      const state = yield* forms
+        .ask({
+          sessionID,
+          title: "Choose a web search provider",
+          metadata: { kind: "websearch.provider" },
+          mode: "form",
+          fields: [
+            {
+              key: "provider",
+              title: "Provider",
+              description: "This becomes your default and can be changed later from Connect integration.",
+              type: "string",
+              required: true,
+              custom: false,
+              options: Array.from(providers.values())
+                .flatMap((provider) => {
+                  const info = infos.get(provider.integrationID)
+                  if (!info) return []
+                  const disconnected = provider.connection === "optional" ? "Keyless available" : "Connection required"
+                  return [{ info, description: info.connections.length ? "Connected" : disconnected }]
+                })
+                .toSorted((a, b) => a.info.name.localeCompare(b.info.name))
+                .map(({ info, description }) => ({
+                  value: info.id,
+                  label: info.name,
+                  description,
+                })),
+            },
+          ],
+        })
+        .pipe(Effect.orDie)
+      if (state.status === "cancelled") return yield* new CancelledError()
+      const answer = state.answer.provider
+      if (typeof answer !== "string") return yield* new ProviderRequiredError()
+      return yield* requireProvider(providers, Integration.ID.make(answer))
+    })
+
+    const connect = Effect.fn("WebSearch.connect")(function* (
+      provider: Integration.WebSearchImplementation,
+      sessionID?: string,
+    ) {
+      const active = yield* integrations.connection.active(provider.integrationID)
+      if (active || provider.connection === "optional") return active
+      if (!sessionID) return yield* new ConnectionRequiredError({ providerID: provider.integrationID })
+      const state = yield* forms
+        .ask({
+          sessionID,
+          title: `Connect ${provider.integrationID}`,
+          metadata: { kind: "integration.connection" },
+          mode: "integration",
+          integrationID: provider.integrationID,
+        })
+        .pipe(Effect.orDie)
+      if (state.status === "cancelled") return yield* new CancelledError()
+      const connected = yield* integrations.connection.active(provider.integrationID)
+      if (!connected) return yield* new ConnectionRequiredError({ providerID: provider.integrationID })
+      return connected
+    })
+
+    const resolve = Effect.fn("WebSearch.resolve")(function* (input: QueryInput) {
+      const providers = new Map(
+        (yield* integrations.websearch.list()).map((provider) => [provider.integrationID, provider]),
+      )
+      if (input.providerID) return yield* requireProvider(providers, input.providerID)
+      const configuredProviderID = Config.latest(yield* config.entries(), "websearch")?.provider
+      if (configuredProviderID) return yield* requireProvider(providers, configuredProviderID)
+      if (process.env.OPENCODE_WEBSEARCH_PROVIDER) {
+        return yield* requireProvider(providers, Integration.ID.make(process.env.OPENCODE_WEBSEARCH_PROVIDER))
+      }
+      if (truthy("OPENCODE_ENABLE_PARALLEL") || truthy("OPENCODE_EXPERIMENTAL_PARALLEL")) {
+        return yield* requireProvider(providers, Integration.ID.make("parallel"))
+      }
+      if (truthy("OPENCODE_EXPERIMENTAL") || truthy("OPENCODE_ENABLE_EXA") || truthy("OPENCODE_EXPERIMENTAL_EXA")) {
+        return yield* requireProvider(providers, Integration.ID.make("exa"))
+      }
+      const providerID = yield* selected()
+      const provider = providerID ? providers.get(providerID) : undefined
+      if (provider) return provider
+      const sessionID = input.sessionID
+      if (!sessionID) return yield* new ProviderRequiredError()
+      return yield* onboarding.withPermit(
+        Effect.gen(function* () {
+          const current = yield* selected()
+          const selectedProvider = current ? providers.get(current) : undefined
+          if (selectedProvider) return selectedProvider
+          const provider = yield* ask(providers, sessionID)
+          yield* connect(provider, sessionID)
+          yield* saveProvider(provider.integrationID)
+          return provider
+        }),
+      )
+    })
+
+    return Service.of({
+      selected,
+      select: Effect.fn("WebSearch.select")(function* (providerID) {
+        const provider = yield* integrations.websearch.get(providerID)
+        if (!provider) return yield* new ProviderNotFoundError({ providerID })
+        yield* saveProvider(providerID)
+      }),
+      query: Effect.fn("WebSearch.query")(function* (input) {
+        const provider = yield* resolve(input)
+        const connection = yield* connect(provider, input.sessionID)
+        const credential = connection
+          ? yield* integrations.connection
+              .resolve(connection)
+              .pipe(Effect.mapError((cause) => new RequestError({ providerID: provider.integrationID, cause })))
+          : undefined
+        const output = yield* provider.execute(input, { credential, sessionID: input.sessionID }).pipe(
+          Effect.flatMap(decodeOutput),
+          Effect.mapError((cause) => new RequestError({ providerID: provider.integrationID, cause })),
+        )
+        return new Result({ providerID: provider.integrationID, ...output })
+      }),
+    })
+  }),
+)
+
+export const node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [Config.node, ConfigGlobal.node, EventV2.node, Form.node, Global.node, Integration.node],
+})

packages/core/test/config/config.test.ts

@@ -4,6 +4,7 @@ import { describe, expect } from "bun:test"
 import { Effect, Fiber, Layer, PubSub, Schema, Stream } from "effect"
 import { FastCheck } from "effect/testing"
 import { Config } from "@opencode-ai/core/config"
+import { ConfigGlobal } from "@opencode-ai/core/config/global"
 import { ConfigModel } from "@opencode-ai/core/config/model"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { ConfigProvider } from "@opencode-ai/core/config/provider"
@@ -22,6 +23,7 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
+import { parse } from "jsonc-parser"
 
 const it = testEffect(Layer.empty)
 const selection = Schema.decodeUnknownSync(ConfigModel.Selection)
@@ -58,6 +60,37 @@ const provider = {
 }
 
 describe("Config", () => {
+  it.live("updates the global JSONC config without removing comments", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    ).pipe(
+      Effect.flatMap((tmp) =>
+        Effect.gen(function* () {
+          const global = path.join(tmp.path, "global")
+          const file = path.join(global, "opencode.jsonc")
+          yield* Effect.promise(async () => {
+            await fs.mkdir(global, { recursive: true })
+            await fs.writeFile(file, `// user config\n{\n  "username": "tester"\n}\n`)
+          })
+
+          const config = yield* ConfigGlobal.Service
+          yield* config.update(["websearch"], { provider: "exa" })
+
+          const text = yield* Effect.promise(() => Bun.file(file).text())
+          expect(text).toContain("// user config")
+          expect(parse(text)).toEqual({ username: "tester", websearch: { provider: "exa" } })
+        }).pipe(
+          Effect.provide(
+            AppNodeBuilder.build(LayerNode.group([ConfigGlobal.node]), [
+              [Global.node, Global.layerWith({ config: path.join(tmp.path, "global") })],
+            ]),
+          ),
+        ),
+      ),
+    ),
+  )
+
   it.live("reloads external config and publishes directory updates", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),

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/mcp.test.ts

@@ -155,6 +155,10 @@ function resourceMcpLayer(url: string) {
             complete: unusedIntegration,
             cancel: unusedIntegration,
           },
+          websearch: {
+            list: unusedIntegration,
+            get: unusedIntegration,
+          },
         }),
         Layer.mock(Credential.Service, {}),
       ),

packages/core/test/plugin/host.ts

@@ -1,16 +1,22 @@
-import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
+import { Plugin } from "@opencode-ai/plugin/v2/effect"
+import type { IntegrationDefinition, IntegrationMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
 import { AgentV2 } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import type { IntegrationEnvMethod, IntegrationKeyMethod, IntegrationOAuthMethod } from "@opencode-ai/sdk/v2/types"
+import type {
+  CredentialOAuth,
+  IntegrationEnvMethod,
+  IntegrationKeyMethod,
+  IntegrationOAuthMethod,
+} from "@opencode-ai/sdk/v2/types"
 import { Effect, Stream } from "effect"
 
-type Overrides = Partial<Omit<PluginContext, "options">>
+type Overrides = Partial<Omit<Plugin.Context, "options">>
 
-export function host(overrides: Overrides = {}): PluginContext {
+export function host(overrides: Overrides = {}): Plugin.Context {
   return {
     options: {},
     agent: overrides.agent ?? {
@@ -53,6 +59,7 @@ export function host(overrides: Overrides = {}): PluginContext {
         complete: () => Effect.die("unused integration.attempt.complete"),
         cancel: () => Effect.die("unused integration.attempt.cancel"),
       },
+      register: () => Effect.die("unused integration.register"),
       transform: () => Effect.die("unused integration.transform"),
       reload: () => Effect.die("unused integration.reload"),
       connection: {
@@ -90,7 +97,7 @@ export function host(overrides: Overrides = {}): PluginContext {
   }
 }
 
-export function agentHost(agent: AgentV2.Interface): PluginContext["agent"] {
+export function agentHost(agent: AgentV2.Interface): Plugin.Context["agent"] {
   return {
     list: () => Effect.die("unused agent.list"),
     reload: agent.reload,
@@ -115,7 +122,7 @@ export function agentHost(agent: AgentV2.Interface): PluginContext["agent"] {
   }
 }
 
-export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"] {
+export function catalogHost(catalog: Catalog.Interface): Plugin.Context["catalog"] {
   return {
     provider: {
       list: () => Effect.die("unused catalog.provider.list"),
@@ -187,7 +194,7 @@ export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"
   }
 }
 
-export function integrationHost(integration: Integration.Interface): PluginContext["integration"] {
+export function integrationHost(integration: Integration.Interface): Plugin.Context["integration"] {
   return {
     list: () => Effect.die("unused integration.list"),
     get: () => Effect.die("unused integration.get"),
@@ -208,6 +215,7 @@ export function integrationHost(integration: Integration.Interface): PluginConte
           connection.type === "credential" ? { ...connection, id: Credential.ID.make(connection.id) } : connection,
         ),
     },
+    register: (definition) => integration.transform((draft) => registerIntegration(draft, definition)),
     transform: (callback) =>
       integration.transform((draft) =>
         callback({
@@ -220,72 +228,7 @@ export function integrationHost(integration: Integration.Interface): PluginConte
           remove: (id) => draft.remove(Integration.ID.make(id)),
           method: {
             list: (id) => draft.method.list(Integration.ID.make(id)).map(method),
-            update: (input) => {
-              if ("authorize" in input) {
-                const methodID = Integration.MethodID.make(input.method.id)
-                const refresh = input.refresh
-                draft.method.update({
-                  integrationID: Integration.ID.make(input.integrationID),
-                  method: { ...input.method, id: methodID },
-                  authorize: (inputs) =>
-                    input.authorize(inputs).pipe(
-                      Effect.map((authorization) => {
-                        if (authorization.mode === "auto") {
-                          return {
-                            ...authorization,
-                            callback: authorization.callback.pipe(
-                              Effect.map((credential) =>
-                                Credential.OAuth.make({
-                                  ...credential,
-                                  methodID: Integration.MethodID.make(credential.methodID),
-                                }),
-                              ),
-                            ),
-                          }
-                        }
-                        return {
-                          ...authorization,
-                          callback: (code: string) =>
-                            authorization.callback(code).pipe(
-                              Effect.map((credential) =>
-                                Credential.OAuth.make({
-                                  ...credential,
-                                  methodID: Integration.MethodID.make(credential.methodID),
-                                }),
-                              ),
-                            ),
-                        }
-                      }),
-                    ),
-                  ...(refresh
-                    ? {
-                        refresh: (value: Credential.OAuth) =>
-                          refresh(value).pipe(
-                            Effect.map((next) =>
-                              Credential.OAuth.make({
-                                ...next,
-                                methodID: Integration.MethodID.make(next.methodID),
-                              }),
-                            ),
-                          ),
-                      }
-                    : {}),
-                  ...(input.label ? { label: input.label } : {}),
-                })
-                return
-              }
-              if (input.method.type === "env") {
-                draft.method.update({
-                  integrationID: Integration.ID.make(input.integrationID),
-                  method: { ...input.method, names: [...input.method.names] },
-                })
-                return
-              }
-              draft.method.update({
-                integrationID: Integration.ID.make(input.integrationID),
-                method: input.method,
-              })
-            },
+            update: (input) => draft.method.update(methodImplementation(input)),
             remove: (id, item) => draft.method.remove(Integration.ID.make(id), internalMethod(item)),
           },
         }),
@@ -293,6 +236,72 @@ export function integrationHost(integration: Integration.Interface): PluginConte
   }
 }
 
+function registerIntegration(draft: Integration.Draft, definition: IntegrationDefinition) {
+  const integrationID = Integration.ID.make(definition.id)
+  draft.update(integrationID, (integration) => (integration.name = definition.name))
+  for (const item of definition.methods ?? []) {
+    if (item.type === "env") {
+      draft.method.update(methodImplementation({ integrationID: definition.id, method: item }))
+      continue
+    }
+    if (item.type === "key") {
+      draft.method.update(methodImplementation({ integrationID: definition.id, method: item }))
+      continue
+    }
+    const { authorize, refresh, credentialLabel, ...method } = item
+    draft.method.update(
+      methodImplementation({
+        integrationID: definition.id,
+        method,
+        authorize,
+        ...(refresh ? { refresh } : {}),
+        ...(credentialLabel ? { label: credentialLabel } : {}),
+      }),
+    )
+  }
+  if (!definition.websearch) return
+  draft.websearch.update({
+    integrationID,
+    connection: definition.websearch.connection,
+    execute: definition.websearch.execute,
+  })
+}
+
+function methodImplementation(input: IntegrationMethodRegistration): Integration.Implementation {
+  if ("authorize" in input) {
+    const refresh = input.refresh
+    return {
+      integrationID: Integration.ID.make(input.integrationID),
+      method: { ...input.method, id: Integration.MethodID.make(input.method.id) },
+      authorize: (inputs) =>
+        input.authorize(inputs).pipe(
+          Effect.map((authorization) => {
+            if (authorization.mode === "auto") {
+              return { ...authorization, callback: authorization.callback.pipe(Effect.map(oauthCredential)) }
+            }
+            return {
+              ...authorization,
+              callback: (code: string) => authorization.callback(code).pipe(Effect.map(oauthCredential)),
+            }
+          }),
+        ),
+      ...(refresh ? { refresh: (value: Credential.OAuth) => refresh(value).pipe(Effect.map(oauthCredential)) } : {}),
+      ...(input.label ? { label: input.label } : {}),
+    }
+  }
+  if (input.method.type === "env") {
+    return {
+      integrationID: Integration.ID.make(input.integrationID),
+      method: { ...input.method, names: [...input.method.names] },
+    }
+  }
+  return { integrationID: Integration.ID.make(input.integrationID), method: input.method }
+}
+
+function oauthCredential(value: CredentialOAuth) {
+  return Credential.OAuth.make({ ...value, methodID: Integration.MethodID.make(value.methodID) })
+}
+
 function method(value: Integration.Method) {
   if (value.type === "env") return { type: value.type, names: [...value.names] }
   if (value.type === "key") return { type: value.type, label: value.label }

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,35 @@ describe("fromPromise", () => {
       expect(yield* agents.get(AgentV2.ID.make("temp"))).toBeUndefined()
     }),
   )
+
+  it.effect("adapts promise web search capability execution", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const plugin = yield* PluginV2.Service
+      const host = yield* PluginHost.make(plugin)
+      const promisePlugin = Plugin.define({
+        id: "promise-websearch",
+        setup: async (ctx) => {
+          await ctx.integration.register({
+            id: "promise-websearch",
+            name: "Promise Web Search",
+            methods: [{ type: "env", names: ["PROMISE_WEBSEARCH_KEY"] }],
+            websearch: {
+              connection: "optional",
+              execute: async (input) => ({ text: `promise: ${input.query}` }),
+            },
+          })
+        },
+      })
+
+      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
+      expect(yield* integrations.get(Integration.ID.make("promise-websearch"))).toMatchObject({
+        name: "Promise Web Search",
+        methods: [{ type: "env", names: ["PROMISE_WEBSEARCH_KEY"] }],
+      })
+      const provider = yield* integrations.websearch.get(Integration.ID.make("promise-websearch"))
+      if (!provider) return yield* Effect.die("Expected promise web search provider")
+      expect(yield* provider.execute({ query: "effect" }, {})).toEqual({ text: "promise: effect" })
+    }),
+  )
 })

packages/core/test/plugin/websearch-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 WebSearchRequest {
+  readonly url: string
+  readonly headers: Record<string, string>
+  readonly body: unknown
+}
+
+export const requests: WebSearchRequest[] = []
+export const response = { body: "" }
+
+export function resetWebSearchFixture(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 webSearchIntegrationTest = testEffect(
+  Layer.merge(AppNodeBuilder.build(LayerNode.group([Integration.node, Credential.node, EventV2.node])), http),
+)

packages/core/test/plugin/websearch.test.ts

@@ -0,0 +1,158 @@
+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 { WebSearchExa } from "@opencode-ai/core/plugin/websearch/exa"
+import { WebSearchParallel } from "@opencode-ai/core/plugin/websearch/parallel"
+import { host, integrationHost } from "./host"
+import { requests, resetWebSearchFixture, webSearchIntegrationTest } from "./websearch-fixture"
+
+beforeEach(() => {
+  resetWebSearchFixture(
+    `event: message\ndata: ${JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      result: { content: [{ type: "text", text: "search results", _meta: { searchTime: 123 } }] },
+    })}\n\n`,
+  )
+})
+
+const it = webSearchIntegrationTest
+
+describe("built-in web search integrations", () => {
+  it.effect("registers and disposes an atomic web search integration", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      const registration = yield* integrationHost(integrations).register({
+        id: "test-websearch",
+        name: "Test Web Search",
+        methods: [{ type: "key", label: "API key" }],
+        websearch: {
+          connection: "required",
+          execute: (input) => Effect.succeed({ text: input.query }),
+        },
+      })
+
+      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toMatchObject({
+        name: "Test Web Search",
+        methods: [{ type: "key", label: "API key" }],
+        websearch: { connection: "required" },
+      })
+      yield* registration.dispose
+      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toBeUndefined()
+    }),
+  )
+
+  it.effect("registers Exa with its MCP schema", () =>
+    Effect.gen(function* () {
+      const integrations = yield* Integration.Service
+      yield* WebSearchExa.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"] }],
+        websearch: { connection: "optional" },
+      })
+      const provider = yield* integrations.websearch.get(Integration.ID.make("exa"))
+      if (!provider) return yield* Effect.die("Expected Exa web search provider")
+      expect(
+        yield* provider.execute(
+          { query: "effect typescript" },
+          { credential: Credential.Key.make({ type: "key", key: "exa secret" }) },
+        ),
+      ).toEqual({ text: "search results", metadata: { searchTime: 123 } })
+      expect(requests).toEqual([
+        {
+          url: `${WebSearchExa.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", numResults: 8 },
+            },
+          },
+        },
+      ])
+    }),
+  )
+
+  it.effect("registers Parallel and keeps its credential in the authorization header", () =>
+    Effect.gen(function* () {
+      resetWebSearchFixture(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          result: {
+            content: [{ type: "text", text: "search results" }],
+            structuredContent: {
+              search_id: "search_1",
+              results: [
+                {
+                  url: "https://effect.website",
+                  title: "Effect",
+                  publish_date: null,
+                  excerpts: ["Effect documentation"],
+                },
+              ],
+              warnings: null,
+              usage: [{ name: "sku_search", count: 1 }],
+              session_id: "ses_parallel",
+            },
+          },
+        }),
+      )
+      const integrations = yield* Integration.Service
+      yield* WebSearchParallel.Plugin.effect(host({ integration: integrationHost(integrations) }))
+      const provider = yield* integrations.websearch.get(Integration.ID.make("parallel"))
+      if (!provider) return yield* Effect.die("Expected Parallel web 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",
+        metadata: {
+          search_id: "search_1",
+          results: [
+            {
+              url: "https://effect.website",
+              title: "Effect",
+              publish_date: null,
+              excerpts: ["Effect documentation"],
+            },
+          ],
+          warnings: null,
+          usage: [{ name: "sku_search", count: 1 }],
+          session_id: "ses_parallel",
+        },
+      })
+      expect(requests[0]).toMatchObject({
+        url: WebSearchParallel.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/tool-websearch.test.ts

@@ -1,104 +1,35 @@
-import { beforeEach, describe, expect, test } from "bun:test"
-import { Effect, Layer, Schema } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
+import { beforeEach, describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
 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 { WebSearch } from "@opencode-ai/core/websearch"
 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, WebSearch.node],
 })
 
 const sessionID = SessionV2.ID.make("ses_websearch_test")
-const payload = (text: string) =>
-  JSON.stringify({
-    jsonrpc: "2.0",
-    id: 1,
-    result: { content: [{ type: "text", text }] },
-  })
-
-describe("WebSearchTool provider selection", () => {
-  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", () => {
-  test("parses plain JSON-RPC responses", async () => {
-    expect(await Effect.runPromise(WebSearchTool.parseResponse(payload("search results")))).toBe("search results")
-  })
-
-  test("parses SSE JSON-RPC responses and ignores non-JSON frames", async () => {
-    expect(
-      await Effect.runPromise(
-        WebSearchTool.parseResponse(`data: [DONE]\nevent: message\ndata: ${payload("search results")}\n\n`),
-      ),
-    ).toBe("search results")
-  })
-})
-
-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: WebSearch.QueryInput[] = []
+let result = new WebSearch.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 WebSearch.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 +41,29 @@ 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 websearch = Layer.succeed(
+  WebSearch.Service,
+  WebSearch.Service.of({
+    selected: () => Effect.succeed(undefined),
+    select: () => Effect.die("unused"),
+    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, WebSearch.node, webSearchToolNode]), [
+    [PermissionV2.node, permission],
+    [WebSearch.node, websearch],
+    [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
+  ]),
 )
 
 describe("WebSearchTool registration", () => {
-  it.effect("registers websearch, asserts query permission, and calls Exa", () =>
+  it.effect("asserts permission before delegating to WebSearch", () =>
     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,122 +73,58 @@ describe("WebSearchTool registration", () => {
           ...toolIdentity,
           call: {
             type: "tool-call",
-            id: "call-exa",
+            id: "call-search",
             name: "websearch",
-            input: {
-              query: "effect typescript",
-              numResults: 3,
-              livecrawl: "preferred",
-              type: "fast",
-              contextMaxCharacters: 2500,
-            },
+            input: { query: "effect typescript" },
           },
         }),
-      ).toEqual({ type: "text", value: "exa results" })
+      ).toEqual({ type: "text", value: "search results" })
       expect(assertions).toMatchObject([
         {
           sessionID,
           action: "websearch",
           resources: ["effect typescript"],
           save: ["*"],
-          metadata: {
-            query: "effect typescript",
-            numResults: 3,
-            livecrawl: "preferred",
-            type: "fast",
-            contextMaxCharacters: 2500,
-            provider: "exa",
-          },
+          metadata: { query: "effect typescript" },
         },
       ])
-      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",
         },
       ])
     }),
   )
 
-  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 WebSearch.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 WebSearch.Result({ providerID: Integration.ID.make("exa"), text: "" })
       const registry = yield* ToolRegistry.Service
 
       expect(
@@ -285,39 +136,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)
-    }),
-  )
 })

packages/core/test/websearch.test.ts

@@ -0,0 +1,175 @@
+import { beforeEach, describe, expect } from "bun:test"
+import { Effect, Exit, Fiber, Layer, Scope } from "effect"
+import path from "node:path"
+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 { ConfigGlobal } from "@opencode-ai/core/config/global"
+import { ConfigWebSearch } from "@opencode-ai/core/config/websearch"
+import { Credential } from "@opencode-ai/core/credential"
+import { EventV2 } from "@opencode-ai/core/event"
+import { Form } from "@opencode-ai/core/form"
+import { Global } from "@opencode-ai/core/global"
+import { Integration } from "@opencode-ai/core/integration"
+import { WebSearch } from "@opencode-ai/core/websearch"
+import { testEffect } from "./lib/effect"
+
+let entries: Config.Entry[] = []
+const writes: { path: readonly (string | number)[]; value: unknown }[] = []
+const config = Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed(entries) }))
+const configGlobal = Layer.succeed(
+  ConfigGlobal.Service,
+  ConfigGlobal.Service.of({ update: (path, value) => Effect.sync(() => writes.push({ path, value })) }),
+)
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([WebSearch.node, Integration.node, Credential.node, EventV2.node, Form.node, ConfigGlobal.node]),
+    [
+      [Config.node, config],
+      [ConfigGlobal.node, configGlobal],
+    ],
+  ),
+)
+
+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: WebSearch.Input; credential?: Credential.Value; sessionID?: string }[] = []
+    yield* integrations.transform((draft) => {
+      draft.update(integrationID, (integration) => (integration.name = id.toUpperCase()))
+      draft.websearch.update({
+        integrationID,
+        connection,
+        execute: (input, context) =>
+          Effect.sync(() => {
+            calls.push({ input, ...context })
+            return { text: `${id}: ${input.query}`, metadata: { id } }
+          }),
+      })
+    })
+    return { integrationID, calls }
+  })
+
+beforeEach(() => {
+  entries = []
+  writes.length = 0
+})
+
+describe("WebSearch", () => {
+  it.effect("executes an explicit provider without changing the default", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("exa")
+      const websearch = yield* WebSearch.Service
+
+      expect(yield* websearch.query({ query: "effect", providerID: provider.integrationID })).toEqual(
+        new WebSearch.Result({
+          providerID: provider.integrationID,
+          text: "exa: effect",
+          metadata: { id: "exa" },
+        }),
+      )
+      expect(yield* websearch.selected()).toBeUndefined()
+      expect(provider.calls).toEqual([
+        {
+          input: { query: "effect", providerID: provider.integrationID },
+          credential: undefined,
+          sessionID: undefined,
+        },
+      ])
+    }),
+  )
+
+  it.effect("uses and persists the global provider selection", () =>
+    Effect.gen(function* () {
+      yield* register("exa")
+      const parallel = yield* register("parallel")
+      const websearch = yield* WebSearch.Service
+      yield* websearch.select(parallel.integrationID)
+
+      expect((yield* websearch.query({ query: "layers" })).providerID).toBe(parallel.integrationID)
+      expect(yield* websearch.selected()).toBe(parallel.integrationID)
+      expect(writes).toEqual([
+        { path: ["websearch"], value: new ConfigWebSearch.Info({ provider: parallel.integrationID }) },
+      ])
+    }),
+  )
+
+  it.effect("reads the selected provider from global config", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("exa")
+      const websearch = yield* WebSearch.Service
+      entries = [
+        new Config.Document({
+          type: "document",
+          path: path.join(Global.Path.config, "opencode.json"),
+          info: new Config.Info({ websearch: new ConfigWebSearch.Info({ provider: provider.integrationID }) }),
+        }),
+      ]
+
+      expect(yield* websearch.selected()).toBe(provider.integrationID)
+      expect((yield* websearch.query({ query: "configured" })).providerID).toBe(provider.integrationID)
+    }),
+  )
+
+  it.effect("prefers the location config over the global selection", () =>
+    Effect.gen(function* () {
+      const exa = yield* register("exa")
+      const parallel = yield* register("parallel")
+      const websearch = yield* WebSearch.Service
+      yield* websearch.select(exa.integrationID)
+      entries = [
+        new Config.Document({
+          type: "document",
+          info: new Config.Info({ websearch: new ConfigWebSearch.Info({ provider: parallel.integrationID }) }),
+        }),
+      ]
+
+      expect((yield* websearch.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 websearch = yield* WebSearch.Service
+      const forms = yield* Form.Service
+      const first = yield* websearch.query({ query: "one", sessionID: "ses_websearch" }).pipe(Effect.forkChild)
+      const second = yield* websearch.query({ query: "two", sessionID: "ses_websearch" }).pipe(Effect.forkChild)
+      yield* Effect.yieldNow
+
+      const pending = yield* forms.list({ sessionID: "ses_websearch" })
+      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* websearch.selected()).toBe(provider.integrationID)
+    }),
+  )
+
+  it.effect("requires a connection before invoking a required provider", () =>
+    Effect.gen(function* () {
+      const provider = yield* register("private", "required")
+      const websearch = yield* WebSearch.Service
+
+      expect(
+        yield* websearch.query({ query: "secret", providerID: provider.integrationID }).pipe(Effect.flip),
+      ).toBeInstanceOf(WebSearch.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.websearch.get(provider.integrationID)).toBeDefined()
+      yield* Scope.close(scope, Exit.void)
+      expect(yield* integrations.websearch.get(provider.integrationID)).toBeUndefined()
+    }),
+  )
+})

packages/llm/AGENTS.md

@@ -113,6 +113,23 @@ Keep provider facades small and explicit:
 
 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
 
+### Provider Package Entrypoints
+
+Catalog-selected native providers use package-like export paths from `@opencode-ai/llm`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+
+```ts
+import { model } from "@opencode-ai/llm/providers/openai/responses"
+
+const selected = model("gpt-5", {
+  apiKey,
+  transport: "websocket",
+})
+```
+
+Keep semantic APIs as separate entrypoints, such as OpenAI `chat` and `responses`. Keep transport choices inside the semantic entrypoint settings, so OpenAI Responses HTTP and WebSocket share one entrypoint. Provider facades may still expose named selectors such as `responsesWebSocket` for direct typed call sites; the package-like contract maps its settings to those selectors before returning an executable `Model`.
+
+Do not expose `Route` in provider package settings. Route composition stays an implementation detail behind `model(...)`.
+
 ### Folder layout
 
 ```

packages/llm/README.md

@@ -106,6 +106,32 @@ const gateway = CloudflareAIGateway.configure({
 
 Included providers: OpenAI, Anthropic, Google (Gemini), Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, plus generic OpenAI-compatible helpers for DeepSeek, Cerebras, Groq, Fireworks, Together, etc.
 
+### Package-like entrypoints
+
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/llm` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
+
+```ts
+import { model } from "@opencode-ai/llm/providers/openai/responses"
+
+const selected = model("gpt-5", {
+  apiKey: process.env.OPENAI_API_KEY,
+  transport: "websocket",
+  headers: { "x-application": "opencode" },
+  limits: { context: 200_000, output: 64_000 },
+})
+```
+
+OpenAI Chat and OpenAI Responses are separate semantic entrypoints:
+
+- `@opencode-ai/llm/providers/openai/chat`
+- `@opencode-ai/llm/providers/openai/responses`
+
+Responses HTTP versus WebSocket is a scoped `transport` setting on the Responses entrypoint, not another entrypoint. Azure follows the same Chat/Responses split at `providers/azure/chat` and `providers/azure/responses`. Anthropic, OpenAI-compatible Chat, Google Gemini, and Amazon Bedrock expose their single native API through their existing provider paths.
+
+Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
+
+Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
+
 ## Provider options & HTTP overlays
 
 Three escape hatches in order of stability:

packages/llm/STATUS.md

@@ -1,6 +1,6 @@
 # LLM Provider Parity Status
 
-Last reviewed: 2026-07-02
+Last reviewed: 2026-07-08
 
 This file tracks the gap between the native `@opencode-ai/llm` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.
 
@@ -64,26 +64,27 @@ Everything else currently fails with `SessionRunnerModel.UnsupportedApiError` wh
 5. Azure is only a provider facade, not a full runtime replacement. Native Azure exists, but the catalog runner does not select it, and token auth/resource variants need review.
 6. Provider option typing is uneven. OpenAI, Anthropic, Gemini, Bedrock, and OpenRouter each expose a small typed subset plus raw HTTP overlays; this is useful but not equivalent to AI SDK provider option coverage.
 7. Structured output is not provider-native yet. `LLM.generateObject` still uses a synthetic tool strategy, while the future design expects native structured output where reliable and tool fallback where needed.
-8. Package/namespace boundaries need to be made explicit in docs and exports. Protocol namespaces exist, but planned public groupings should call out OpenAI Chat, OpenAI Responses, OpenAI-compatible Chat, OpenAI-compatible Responses, Anthropic Messages, Gemini, Vertex Gemini, Vertex Anthropic Messages, Bedrock Converse, and Bedrock Mantle as separate API slices.
+8. Package/namespace boundaries for the current native loading set are explicit in docs and exports. Other exported provider facades are not catalog package entrypoints until they implement the contract. Missing native API boundaries remain for OpenAI-compatible Responses, Vertex Gemini, Vertex Anthropic Messages, and Bedrock Mantle.
 9. Recorded coverage is uneven. OpenAI, Anthropic, Gemini, Bedrock Converse, Cloudflare, OpenRouter, and several OpenAI-compatible Chat providers have cassettes. Azure, Vertex, and Mantle need first-class recorded scenarios before switching defaults.
 
-## Proposed Native Namespace Shape
+## Native Namespace Shape
 
 These are implementation/API slices, not separate npm packages.
 
-| Namespace | Purpose |
-| --- | --- |
-| `OpenAI.Chat` or `OpenAIChat` | OpenAI `/chat/completions` semantics. |
-| `OpenAI.Responses` or `OpenAIResponses` | OpenAI `/responses` HTTP and WebSocket semantics. |
-| `OpenAICompatible.Chat` or `OpenAICompatibleChat` | Generic OpenAI-compatible `/chat/completions`. |
-| `OpenAICompatible.Responses` or `OpenAICompatibleResponses` | Generic OpenAI-compatible `/responses`. Missing today. |
-| `Anthropic.Messages` or `AnthropicMessages` | Anthropic Messages API. |
-| `Google.Gemini` or `Gemini` | Gemini Developer API. |
-| `GoogleVertex.Gemini` | Vertex Gemini API. Missing today. |
-| `GoogleVertex.AnthropicMessages` | Vertex-hosted Anthropic Messages API. Missing today. |
-| `Bedrock.Converse` or `BedrockConverse` | AWS Bedrock Converse API. |
-| `Bedrock.Mantle` | AWS Bedrock Mantle OpenAI-compatible APIs. Missing today. |
-| `Azure.OpenAIChat` / `Azure.OpenAIResponses` | Azure deployment specializations over OpenAI protocols. |
+| API slice | Package-like entrypoint | Purpose |
+| --- | --- | --- |
+| OpenAI Chat | `@opencode-ai/llm/providers/openai/chat` | OpenAI `/chat/completions` semantics. |
+| OpenAI Responses | `@opencode-ai/llm/providers/openai/responses` | OpenAI `/responses` semantics with HTTP/WebSocket selected through settings. |
+| OpenAI-compatible Chat | `@opencode-ai/llm/providers/openai-compatible` | Generic OpenAI-compatible `/chat/completions`. |
+| OpenAI-compatible Responses | Missing | Generic OpenAI-compatible `/responses`. |
+| Anthropic Messages | `@opencode-ai/llm/providers/anthropic` | Anthropic Messages API. |
+| Gemini Developer API | `@opencode-ai/llm/providers/google` | Google AI Studio Gemini API. |
+| Vertex Gemini | Missing | Vertex Gemini API. |
+| Vertex Anthropic Messages | Missing | Vertex-hosted Anthropic Messages API. |
+| Bedrock Converse | `@opencode-ai/llm/providers/amazon-bedrock` | AWS Bedrock Converse API. |
+| Bedrock Mantle | Missing | AWS Bedrock Mantle OpenAI-compatible APIs. |
+| Azure OpenAI Chat | `@opencode-ai/llm/providers/azure/chat` | Azure specialization of OpenAI Chat. |
+| Azure OpenAI Responses | `@opencode-ai/llm/providers/azure/responses` | Azure specialization of OpenAI Responses. |
 
 ## Suggested Next Work Slices
 

packages/llm/example/call-sites.md

@@ -342,14 +342,24 @@ const response =
   )
 ```
 
-HTTP versus WebSocket is represented as named route selectors, not as model or
-request overrides. Same protocol, different transport, different route:
+For direct provider-facade calls, HTTP versus WebSocket is represented as named
+route selectors, not as model or request overrides. Same protocol, different
+transport, different route:
 
 ```ts
 OpenAI.responses("gpt-4o")
 OpenAI.responsesWebSocket("gpt-4o")
 ```
 
+The package-like OpenAI Responses entrypoint instead keeps transport scoped to
+Responses settings while preserving the same `model(...)` contract:
+
+```ts
+import { model } from "@opencode-ai/llm/providers/openai/responses"
+
+model("gpt-4o", { apiKey, transport: "websocket" })
+```
+
 The client should not require a different public layer just because a selected
 route uses WebSocket. Use one `LLMClient.layer` with HTTP and WebSocket runtime
 capabilities available; routes that do not need WebSocket simply never touch it.
@@ -468,10 +478,10 @@ const model =
 ```
 
 That boundary can branch on durable config/catalog metadata and call typed
-provider APIs directly. Transport selection belongs there too: map metadata like
-`endpoint.websocket` to `OpenAI.responsesWebSocket(apiModelID)`; otherwise use
-the normal `OpenAI.responses(apiModelID)` route. The client runtime only executes
-the route carried by the model.
+provider APIs directly. A direct provider-facade boundary maps metadata like
+`endpoint.websocket` to `OpenAI.responsesWebSocket(apiModelID)`. A package-loading
+boundary passes `transport: "websocket"` to the OpenAI Responses entrypoint.
+The client runtime only executes the route carried by the resulting model.
 
 ## Competitive Shape
 
@@ -507,8 +517,9 @@ App boundary = explicit durable-config -> typed-provider call
   id.
 - No `model(id, overrides)` escape hatch. Model selection takes the model id;
   endpoint/auth/deployment customization happens by configuring the route first.
-- No transport override on model/request. HTTP SSE versus WebSocket is a named
-  route selector such as `responses` versus `responsesWebSocket`.
+- No transport override on an executable model or request. Direct provider
+  facades use `responses` versus `responsesWebSocket`; the package-like Responses
+  entrypoint maps its scoped `transport` setting before constructing the model.
 - No separate public `LLMClient.layerWithWebSocket`. The runtime should expose one
   client layer with the available transport capabilities.
 - No executable `ModelRef`. The executable handle is `Model`; durable model

packages/llm/package.json

@@ -19,6 +19,8 @@
     "./providers/amazon-bedrock": "./src/providers/amazon-bedrock.ts",
     "./providers/anthropic": "./src/providers/anthropic.ts",
     "./providers/azure": "./src/providers/azure.ts",
+    "./providers/azure/responses": "./src/providers/azure/responses.ts",
+    "./providers/azure/chat": "./src/providers/azure/chat.ts",
     "./providers/cloudflare": "./src/providers/cloudflare.ts",
     "./providers/github-copilot": "./src/providers/github-copilot.ts",
     "./providers/google": "./src/providers/google.ts",

packages/llm/src/providers/azure.ts

@@ -1,6 +1,7 @@
 import { Auth } from "../route/auth"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
 import type { Route as RouteDef, RouteDefaultsInput } from "../route/client"
+import type { ProviderPackage } from "../provider-package"
 import { ProviderID, type ModelID } from "../schema"
 import * as OpenAIChat from "../protocols/openai-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
@@ -23,6 +24,14 @@ export type ModelOptions = AzureURL &
   }
 export type Config = ModelOptions
 
+export type Settings = ProviderPackage.Settings &
+  AzureURL & {
+    readonly apiKey?: string
+    readonly apiVersion?: string
+    readonly queryParams?: Readonly<Record<string, string>>
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }
+
 const resourceBaseURL = (resourceName: string) => `https://${resourceName.trim()}.openai.azure.com/openai/v1`
 
 const responsesRoute = OpenAIResponses.route.with({
@@ -108,3 +117,24 @@ export const provider = {
   id,
   configure,
 }
+
+const config = (settings: Settings): Config => {
+  const common = {
+    apiKey: settings.apiKey,
+    apiVersion: settings.apiVersion,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
+    providerOptions: settings.providerOptions,
+    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
+  }
+  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
+  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
+  throw new Error("Azure requires resourceName or baseURL")
+}
+
+export const responsesModel: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+  configure(config(settings)).responses(modelID)
+export const chatModel: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+  configure(config(settings)).chat(modelID)
+export const model = responsesModel

packages/llm/src/providers/azure/chat.ts

@@ -0,0 +1,2 @@
+export { chatModel as model } from "../azure"
+export type { Settings } from "../azure"

packages/llm/src/providers/azure/responses.ts

@@ -0,0 +1,2 @@
+export { responsesModel as model } from "../azure"
+export type { Settings } from "../azure"

packages/llm/src/providers/google.ts

@@ -1,7 +1,8 @@
 import type { RouteDefaultsInput } from "../route/client"
 import { Auth } from "../route/auth"
 import type { ProviderAuthOption } from "../route/auth-options"
-import { ProviderID, type ModelID } from "../schema"
+import type { ProviderPackage } from "../provider-package"
+import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
 import * as Gemini from "../protocols/gemini"
 
 export const id = ProviderID.make("google")
@@ -10,6 +11,12 @@ export const routes = [Gemini.route]
 
 export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & { readonly baseURL?: string }
 
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: ProviderOptions
+}
+
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
   return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
@@ -32,4 +39,12 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model = provider.model
+export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)

packages/llm/test/provider-package.test.ts

@@ -10,10 +10,15 @@ describe("provider package entrypoints", () => {
       import("@opencode-ai/llm/providers/anthropic"),
       import("@opencode-ai/llm/providers/openai-compatible"),
       import("@opencode-ai/llm/providers/amazon-bedrock"),
+      import("@opencode-ai/llm/providers/azure"),
+      import("@opencode-ai/llm/providers/azure/responses"),
+      import("@opencode-ai/llm/providers/azure/chat"),
+      import("@opencode-ai/llm/providers/google"),
     ])
 
     for (const module of modules) expect(module.model).toBeFunction()
     expect(modules[0].model).toBe(modules[1].model)
+    expect(modules[6].model).toBe(modules[7].model)
   })
 
   test("maps package settings onto the executable model", () => {
@@ -49,4 +54,49 @@ describe("provider package entrypoints", () => {
       "OpenAI-Project": "proj_123",
     })
   })
+
+  test("selects Azure API entrypoints with the same model contract", async () => {
+    const Azure = await import("@opencode-ai/llm/providers/azure")
+    const AzureChat = await import("@opencode-ai/llm/providers/azure/chat")
+    const AzureResponses = await import("@opencode-ai/llm/providers/azure/responses")
+    const settings = {
+      apiKey: "fixture",
+      resourceName: "opencode-test",
+      headers: { "x-application": "opencode" },
+      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
+    }
+
+    const responses = AzureResponses.model("deployment", settings)
+    const chat = AzureChat.model("deployment", settings)
+
+    expect(Azure.model("deployment", settings).route.id).toBe("azure-openai-responses")
+    expect(responses.route.id).toBe("azure-openai-responses")
+    expect(responses.route.endpoint.baseURL).toBe("https://opencode-test.openai.azure.com/openai/v1")
+    expect(responses.route.defaults.headers).toEqual({ "x-application": "opencode" })
+    expect(responses.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(responses.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
+    expect(chat.route.id).toBe("azure-openai-chat")
+  })
+
+  test("maps Google package settings onto the Gemini model", async () => {
+    const Google = await import("@opencode-ai/llm/providers/google")
+    const selected = Google.model("gemini-2.5-flash", {
+      apiKey: "fixture",
+      baseURL: "https://generativelanguage.test/v1beta",
+      headers: { "x-application": "opencode" },
+      body: { safetySettings: [] },
+      limits: { context: 1_000_000, output: 65_536 },
+      providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 1_024 } } },
+    })
+
+    expect(selected.route.id).toBe("gemini")
+    expect(selected.route.endpoint.baseURL).toBe("https://generativelanguage.test/v1beta")
+    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
+    expect(selected.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(selected.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
+    expect(selected.route.defaults.providerOptions).toEqual({
+      gemini: { thinkingConfig: { thinkingBudget: 1_024 } },
+    })
+  })
 })

packages/plugin/src/v2/effect/integration.ts

@@ -10,8 +10,9 @@ import type {
   IntegrationRef,
 } from "@opencode-ai/sdk/v2/types"
 import type { IntegrationApi } from "@opencode-ai/client/effect/api"
+import type { WebSearch } from "@opencode-ai/schema/websearch"
 import type { Effect, Scope } from "effect"
-import type { Transform } from "./registration.js"
+import type { Registration, Transform } from "./registration.js"
 
 export type IntegrationOAuthAuthorization = {
   readonly url: string
@@ -44,6 +45,29 @@ export type IntegrationMethodRegistration =
       readonly method: IntegrationEnvMethod
     }
 
+export type IntegrationOAuthMethodDefinition = IntegrationOAuthMethod & {
+  readonly authorize: (inputs: IntegrationInputs) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>
+  readonly refresh?: (credential: CredentialOAuth) => Effect.Effect<CredentialOAuth, unknown>
+  readonly credentialLabel?: (credential: CredentialOAuth) => string | undefined
+}
+
+export type IntegrationMethodDefinition = IntegrationOAuthMethodDefinition | IntegrationKeyMethod | IntegrationEnvMethod
+
+export interface IntegrationWebSearchDefinition {
+  readonly connection: "optional" | "required"
+  readonly execute: (
+    input: WebSearch.Input,
+    context: { readonly credential?: CredentialValue; readonly sessionID?: string },
+  ) => Effect.Effect<WebSearch.ProviderOutput, unknown>
+}
+
+export interface IntegrationDefinition {
+  readonly id: string
+  readonly name: string
+  readonly methods?: readonly IntegrationMethodDefinition[]
+  readonly websearch?: IntegrationWebSearchDefinition
+}
+
 export interface IntegrationDraft {
   list(): readonly IntegrationRef[]
   get(id: string): IntegrationRef | undefined
@@ -57,6 +81,7 @@ export interface IntegrationDraft {
 }
 
 export interface IntegrationDomain extends IntegrationApi<unknown> {
+  readonly register: (definition: IntegrationDefinition) => Effect.Effect<Registration, never, Scope.Scope>
   readonly transform: Transform<IntegrationDraft>
   readonly reload: () => Effect.Effect<void>
   readonly connection: {

packages/plugin/src/v2/promise/integration.ts

@@ -1,11 +1,57 @@
 import type { IntegrationApi } from "@opencode-ai/client/promise/api"
 import type { IntegrationDraft, IntegrationMethodRegistration } from "../effect/integration.js"
-import type { CredentialValue } from "@opencode-ai/sdk/v2/types"
-import type { Transform } from "./registration.js"
+import type {
+  CredentialOAuth,
+  CredentialValue,
+  IntegrationEnvMethod,
+  IntegrationInputs,
+  IntegrationKeyMethod,
+  IntegrationOAuthMethod,
+} from "@opencode-ai/sdk/v2/types"
+import type { WebSearch } from "@opencode-ai/schema/websearch"
+import type { Registration, Transform } from "./registration.js"
 
 export type { IntegrationDraft, IntegrationMethodRegistration }
 
+export type IntegrationOAuthAuthorization = {
+  readonly url: string
+  readonly instructions: string
+} & (
+  | {
+      readonly mode: "auto"
+      readonly callback: Promise<CredentialOAuth>
+    }
+  | {
+      readonly mode: "code"
+      readonly callback: (code: string) => Promise<CredentialOAuth>
+    }
+)
+
+export type IntegrationOAuthMethodDefinition = IntegrationOAuthMethod & {
+  readonly authorize: (inputs: IntegrationInputs) => Promise<IntegrationOAuthAuthorization>
+  readonly refresh?: (credential: CredentialOAuth) => Promise<CredentialOAuth>
+  readonly credentialLabel?: (credential: CredentialOAuth) => string | undefined
+}
+
+export type IntegrationMethodDefinition = IntegrationOAuthMethodDefinition | IntegrationKeyMethod | IntegrationEnvMethod
+
+export interface IntegrationWebSearchDefinition {
+  readonly connection: "optional" | "required"
+  readonly execute: (
+    input: WebSearch.Input,
+    context: { readonly credential?: CredentialValue; readonly sessionID?: string; readonly signal: AbortSignal },
+  ) => Promise<WebSearch.ProviderOutput>
+}
+
+export interface IntegrationDefinition {
+  readonly id: string
+  readonly name: string
+  readonly methods?: readonly IntegrationMethodDefinition[]
+  readonly websearch?: IntegrationWebSearchDefinition
+}
+
 export interface IntegrationDomain extends IntegrationApi {
+  readonly register: (definition: IntegrationDefinition) => Promise<Registration>
   readonly transform: Transform<IntegrationDraft>
   readonly reload: () => Promise<void>
   readonly connection: {

packages/plugin/test/contract-identity.test.ts

@@ -15,7 +15,7 @@ const PromisePlugin = await import("../src/v2/promise/index")
 test.each([
   ["effect", Plugin],
   ["promise", PromisePlugin],
-])("%s entrypoint exposes its canonical Schema contracts", (name, entrypoint) => {
+])("%s entrypoint exposes its canonical Schema contracts", (_name, entrypoint) => {
   expect(entrypoint.Agent).toBe(Agent)
   expect(entrypoint.Command).toBe(Command)
   expect(entrypoint.Connection).toBe(Connection)
@@ -32,10 +32,9 @@ test.each([
     "Credential",
     "Integration",
     "Model",
+    "Plugin",
     "Provider",
     "Reference",
     "Skill",
-    ...(name === "effect" ? ["Tool"] : []),
-    "define",
   ])
 })

packages/protocol/src/api.ts

@@ -24,6 +24,7 @@ import { ReferenceGroup } from "./groups/reference.js"
 import { Authorization } from "./middleware/authorization.js"
 import { LocationGroup } from "./groups/location.js"
 import { IntegrationGroup } from "./groups/integration.js"
+import { WebSearchGroup } from "./groups/websearch.js"
 import { McpGroup } from "./groups/mcp.js"
 import { CredentialGroup } from "./groups/credential.js"
 import { ProjectGroup } from "./groups/project.js"
@@ -38,6 +39,7 @@ type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
   | HttpApiGroup.AddMiddleware<typeof GenerateGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ProviderGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof IntegrationGroup, LocationId>
+  | HttpApiGroup.AddMiddleware<typeof WebSearchGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof McpGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof CredentialGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ProjectGroup, LocationId>
@@ -168,6 +170,7 @@ const makeApiFromGroup = <
     .add(ProjectCopyGroup.middleware(locationMiddleware))
     .add(VcsGroup.middleware(locationMiddleware))
     .add(DebugGroup)
+    .add(WebSearchGroup.middleware(locationMiddleware))
     .annotateMerge(
       OpenApi.annotations({
         title: "opencode HttpApi",

packages/protocol/src/client.ts

@@ -44,6 +44,7 @@ export const groupNames = {
   "server.generate": "generate",
   "server.provider": "provider",
   "server.integration": "integration",
+  "server.websearch": "websearch",
   "server.credential": "credential",
   "server.form": "form",
   "server.permission": "permission",

packages/protocol/src/groups/websearch.ts

@@ -0,0 +1,62 @@
+import { Integration } from "@opencode-ai/schema/integration"
+import { Location } from "@opencode-ai/schema/location"
+import { WebSearch } from "@opencode-ai/schema/websearch"
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import { InvalidRequestError, ServiceUnavailableError } from "../errors.js"
+import { LocationQuery, locationQueryOpenApi } from "./location.js"
+
+export const WebSearchGroup = HttpApiGroup.make("server.websearch")
+  .add(
+    HttpApiEndpoint.get("websearch.provider.get", "/api/websearch/provider", {
+      query: LocationQuery,
+      success: Location.response(Schema.UndefinedOr(Integration.ID)),
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.websearch.provider.get",
+          summary: "Get default web search provider",
+          description: "Return the globally selected web search provider.",
+        }),
+      ),
+  )
+  .add(
+    HttpApiEndpoint.post("websearch.provider.select", "/api/websearch/provider", {
+      query: LocationQuery,
+      payload: Schema.Struct({ providerID: Integration.ID }),
+      success: HttpApiSchema.NoContent,
+      error: [InvalidRequestError, ServiceUnavailableError],
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.websearch.provider.select",
+          summary: "Select default web search provider",
+          description: "Persist the global web search provider in the user configuration.",
+        }),
+      ),
+  )
+  .add(
+    HttpApiEndpoint.post("websearch.query", "/api/websearch", {
+      query: LocationQuery,
+      payload: Schema.Struct(WebSearch.Input.fields),
+      success: Location.response(WebSearch.Result),
+      error: [InvalidRequestError, ServiceUnavailableError],
+    })
+      .annotateMerge(locationQueryOpenApi)
+      .annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.websearch.query",
+          summary: "Search the web",
+          description:
+            "Run one web search through the selected integration. Specify a provider to override the configured default.",
+        }),
+      ),
+  )
+  .annotateMerge(
+    OpenApi.annotations({
+      title: "websearch",
+      description: "Location-scoped web search routes.",
+    }),
+  )

packages/schema/src/form.ts

@@ -3,6 +3,7 @@ export * as Form from "./form.js"
 import { Schema } from "effect"
 import { ephemeral, inventory } from "./event.js"
 import { ascending } from "./identifier.js"
+import { IntegrationID } from "./integration-id.js"
 import { NonNegativeInt, optional, statics } from "./schema.js"
 
 const IDSchema = Schema.String.check(Schema.isStartsWith("frm_")).pipe(Schema.brand("Form.ID"))
@@ -124,8 +125,15 @@ export const UrlInfo = Schema.Struct({
 }).annotate({ identifier: "Form.UrlInfo" })
 export interface UrlInfo extends Schema.Schema.Type<typeof UrlInfo> {}
 
-export const Info = Schema.Union([FormInfo, UrlInfo]).pipe(Schema.toTaggedUnion("mode"))
-export type Info = FormInfo | UrlInfo
+export const IntegrationInfo = Schema.Struct({
+  ...InfoBase,
+  mode: Schema.Literal("integration"),
+  integrationID: IntegrationID,
+}).annotate({ identifier: "Form.IntegrationInfo" })
+export interface IntegrationInfo extends Schema.Schema.Type<typeof IntegrationInfo> {}
+
+export const Info = Schema.Union([FormInfo, UrlInfo, IntegrationInfo]).pipe(Schema.toTaggedUnion("mode"))
+export type Info = FormInfo | UrlInfo | IntegrationInfo
 
 export const Value = Schema.Union([Schema.String, Schema.Number, Schema.Boolean, Schema.Array(Schema.String)]).annotate(
   {

packages/schema/src/index.ts

@@ -18,6 +18,7 @@ export { Project } from "./project.js"
 export { ProjectCopy } from "./project-copy.js"
 export { Provider } from "./provider.js"
 export { Reference } from "./reference.js"
+export { WebSearch } from "./websearch.js"
 export { Session } from "./session.js"
 export { Vcs } from "./vcs.js"
 export { SessionInput } from "./session-input.js"

packages/schema/src/integration.ts

@@ -76,6 +76,11 @@ export type Method = typeof Method.Type
 export const Inputs = Schema.Record(Schema.String, Schema.String).annotate({ identifier: "Integration.Inputs" })
 export type Inputs = typeof Inputs.Type
 
+export interface WebSearch extends Schema.Schema.Type<typeof WebSearch> {}
+export const WebSearch = Schema.Struct({
+  connection: Schema.Literals(["optional", "required"]),
+}).annotate({ identifier: "Integration.WebSearch" })
+
 const Updated = ephemeral({
   type: "integration.updated",
   schema: {},
@@ -96,6 +101,7 @@ export class Info extends Schema.Class<Info>("Integration.Info")({
   id: ID,
   name: Schema.String,
   methods: Schema.Array(Method),
+  websearch: optional(WebSearch),
   connections: Schema.Array(Connection.Info),
 }) {}
 

packages/schema/src/websearch.ts

@@ -0,0 +1,22 @@
+export * as WebSearch from "./websearch.js"
+
+import { Schema } from "effect"
+import { IntegrationID } from "./integration-id.js"
+import { optional } from "./schema.js"
+
+export interface Input extends Schema.Schema.Type<typeof Input> {}
+export const Input = Schema.Struct({
+  query: Schema.String,
+  providerID: IntegrationID.pipe(optional),
+}).annotate({ identifier: "WebSearch.Input" })
+
+export interface ProviderOutput extends Schema.Schema.Type<typeof ProviderOutput> {}
+export const ProviderOutput = Schema.Struct({
+  text: Schema.String,
+  metadata: Schema.Json.pipe(optional),
+}).annotate({ identifier: "WebSearch.ProviderOutput" })
+
+export class Result extends Schema.Class<Result>("WebSearch.Result")({
+  providerID: IntegrationID,
+  ...ProviderOutput.fields,
+}) {}

packages/sdk-next/src/index.ts

@@ -20,6 +20,7 @@ export { Provider } from "@opencode-ai/schema/provider"
 export { Pty } from "@opencode-ai/schema/pty"
 export { Question } from "@opencode-ai/schema/question"
 export { Reference } from "@opencode-ai/schema/reference"
+export { WebSearch } from "@opencode-ai/schema/websearch"
 export { AbsolutePath, RelativePath } from "@opencode-ai/schema/schema"
 export { Session } from "@opencode-ai/schema/session"
 export { SessionInput } from "@opencode-ai/schema/session-input"

packages/sdk-next/test/contract-identity.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from "bun:test"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Model } from "@opencode-ai/schema/model"
+import { WebSearch } from "@opencode-ai/schema/websearch"
 import { Session } from "@opencode-ai/schema/session"
 
 const SDK = await import("../src/index")
@@ -8,6 +9,7 @@ const SDK = await import("../src/index")
 test("re-exports canonical contracts directly from Schema", () => {
   expect(SDK.Agent).toBe(Agent)
   expect(SDK.Model).toBe(Model)
+  expect(SDK.WebSearch).toBe(WebSearch)
   expect(SDK.Session).toBe(Session)
   expect(Object.keys(SDK).sort()).toEqual([
     "AbsolutePath",
@@ -36,5 +38,6 @@ test("re-exports canonical contracts directly from Schema", () => {
     "SessionMessage",
     "Skill",
     "Tool",
+    "WebSearch",
   ])
 })

packages/sdk-next/test/embedded.test.ts

@@ -302,6 +302,39 @@ it.live(
   10_000,
 )
 
+it.live("embedded client exposes integration-backed web search", () =>
+  withEmbedded("opencode-embedded-websearch-", (fixture) =>
+    Effect.gen(function* () {
+      const opencode = yield* fixture.sdk.OpenCode.create()
+      const providerID = fixture.sdk.Integration.ID.make("embedded-websearch")
+      yield* opencode.plugin({
+        id: `embedded-websearch-${crypto.randomUUID()}`,
+        effect: (ctx) =>
+          ctx.integration.register({
+            id: providerID,
+            name: "Embedded web search",
+            websearch: {
+              connection: "optional",
+              execute: (input) => Effect.succeed({ text: `Found ${input.query}`, metadata: { source: "embedded" } }),
+            },
+          }),
+      })
+
+      const result = yield* opencode.websearch.query({
+        query: "opencode",
+        providerID,
+        location: location(fixture),
+      })
+
+      expect(result.data).toEqual({
+        providerID,
+        text: "Found opencode",
+        metadata: { source: "embedded" },
+      })
+    }),
+  ),
+)
+
 it.live(
   "Location-owned runner events reach the ready global client",
   () =>

packages/sdk/js/src/v2/gen/sdk.gen.ts

@@ -462,6 +462,12 @@ import type {
   V2VcsDiffResponses,
   V2VcsStatusErrors,
   V2VcsStatusResponses,
+  V2WebsearchProviderGetErrors,
+  V2WebsearchProviderGetResponses,
+  V2WebsearchProviderSelectErrors,
+  V2WebsearchProviderSelectResponses,
+  V2WebsearchQueryErrors,
+  V2WebsearchQueryResponses,
   VcsApplyErrors,
   VcsApplyResponses,
   VcsDiffErrors,
@@ -8253,6 +8259,123 @@ export class Debug extends HeyApiClient {
   }
 }
 
+export class Provider3 extends HeyApiClient {
+  /**
+   * Get default web search provider
+   *
+   * Return the globally selected web search provider.
+   */
+  public get<ThrowOnError extends boolean = false>(
+    parameters?: {
+      location?: {
+        directory?: string | null
+        workspace?: string | null
+      } | null
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "query", key: "location" }] }])
+    return (options?.client ?? this.client).get<
+      V2WebsearchProviderGetResponses,
+      V2WebsearchProviderGetErrors,
+      ThrowOnError
+    >({
+      url: "/api/websearch/provider",
+      ...options,
+      ...params,
+    })
+  }
+
+  /**
+   * Select default web search provider
+   *
+   * Persist the global web search provider in the user configuration.
+   */
+  public select<ThrowOnError extends boolean = false>(
+    parameters?: {
+      location?: {
+        directory?: string | null
+        workspace?: string | null
+      } | null
+      providerID?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "location" },
+            { in: "body", key: "providerID" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<
+      V2WebsearchProviderSelectResponses,
+      V2WebsearchProviderSelectErrors,
+      ThrowOnError
+    >({
+      url: "/api/websearch/provider",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+}
+
+export class Websearch extends HeyApiClient {
+  /**
+   * Search the web
+   *
+   * Run one web search through the selected integration. Specify a provider to override the configured default.
+   */
+  public query<ThrowOnError extends boolean = false>(
+    parameters?: {
+      location?: {
+        directory?: string | null
+        workspace?: string | null
+      } | null
+      query?: string
+      providerID?: string
+    },
+    options?: Options<never, ThrowOnError>,
+  ) {
+    const params = buildClientParams(
+      [parameters],
+      [
+        {
+          args: [
+            { in: "query", key: "location" },
+            { in: "body", key: "query" },
+            { in: "body", key: "providerID" },
+          ],
+        },
+      ],
+    )
+    return (options?.client ?? this.client).post<V2WebsearchQueryResponses, V2WebsearchQueryErrors, ThrowOnError>({
+      url: "/api/websearch",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers,
+      },
+    })
+  }
+
+  private _provider?: Provider3
+  get provider(): Provider3 {
+    return (this._provider ??= new Provider3({ client: this.client }))
+  }
+}
+
 export class V2 extends HeyApiClient {
   private _health?: Health
   get health(): Health {
@@ -8383,6 +8506,11 @@ export class V2 extends HeyApiClient {
   get debug(): Debug {
     return (this._debug ??= new Debug({ client: this.client }))
   }
+
+  private _websearch?: Websearch
+  get websearch(): Websearch {
+    return (this._websearch ??= new Websearch({ client: this.client }))
+  }
 }
 
 export class OpencodeClient extends HeyApiClient {

packages/sdk/js/src/v2/gen/types.gen.ts

@@ -1431,7 +1431,7 @@ export type GlobalEvent = {
         id: string
         type: "form.created"
         properties: {
-          form: FormFormInfo | FormUrlInfo
+          form: FormFormInfo | FormUrlInfo | FormIntegrationInfo
         }
       }
     | {
@@ -3571,6 +3571,15 @@ export type FormUrlInfo = {
   url: string
 }
 
+export type FormIntegrationInfo = {
+  id: string
+  sessionID: string
+  title?: string
+  metadata?: FormMetadata
+  mode: "integration"
+  integrationID: string
+}
+
 export type FormValue =
   | string
   | number
@@ -5712,6 +5721,10 @@ export type IntegrationEnvMethod = {
   names: Array<string>
 }
 
+export type IntegrationWebSearch = {
+  connection: "optional" | "required"
+}
+
 export type ConnectionCredentialInfo = {
   type: "credential"
   id: string
@@ -5729,6 +5742,7 @@ export type IntegrationInfo = {
   id: string
   name: string
   methods: Array<IntegrationMethod>
+  websearch?: IntegrationWebSearch
   connections: Array<ConnectionInfo>
 }
 
@@ -6557,7 +6571,7 @@ export type FormCreated = {
   type: "form.created"
   location?: LocationRef
   data: {
-    form: FormFormInfo | FormUrlInfo
+    form: FormFormInfo | FormUrlInfo | FormIntegrationInfo
   }
 }
 
@@ -7021,6 +7035,12 @@ export type ProjectCopyCopy = {
 
 export type VcsMode = "working" | "branch"
 
+export type WebSearchResult = {
+  providerID: string
+  text: string
+  metadata?: unknown
+}
+
 export type EventModelsDevRefreshed = {
   id: string
   type: "models-dev.refreshed"
@@ -7844,7 +7864,7 @@ export type EventFormCreated = {
   id: string
   type: "form.created"
   properties: {
-    form: FormFormInfo | FormUrlInfo
+    form: FormFormInfo | FormUrlInfo | FormIntegrationInfo
   }
 }
 
@@ -9893,6 +9913,15 @@ export type FormUrlInfoV2 = {
   url: string
 }
 
+export type FormIntegrationInfoV2 = {
+  id: string
+  sessionID: string
+  title?: string
+  metadata?: FormMetadata
+  mode: "integration"
+  integrationID: string
+}
+
 export type FormCreatePayloadV2 = {
   id?: string | null
   title?: string
@@ -10628,6 +10657,15 @@ export type FormUrlInfo1 = {
   url: string
 }
 
+export type FormIntegrationInfo1 = {
+  id: string
+  sessionID: string
+  title?: string
+  metadata?: FormMetadata1
+  mode: "integration"
+  integrationID: string
+}
+
 export type FormCreatedV2 = {
   id: string
   created: number
@@ -10637,7 +10675,7 @@ export type FormCreatedV2 = {
   type: "form.created"
   location?: LocationRefV2
   data: {
-    form: FormFormInfo1 | FormUrlInfo1
+    form: FormFormInfo1 | FormUrlInfo1 | FormIntegrationInfo1
   }
 }
 
@@ -17194,7 +17232,7 @@ export type V2FormRequestListResponses = {
    */
   200: {
     location: LocationInfoV2
-    data: Array<FormFormInfoV2 | FormUrlInfoV2>
+    data: Array<FormFormInfoV2 | FormUrlInfoV2 | FormIntegrationInfoV2>
   }
 }
 
@@ -17231,7 +17269,7 @@ export type V2SessionFormListResponses = {
    * Success
    */
   200: {
-    data: Array<FormFormInfoV2 | FormUrlInfoV2>
+    data: Array<FormFormInfoV2 | FormUrlInfoV2 | FormIntegrationInfoV2>
   }
 }
 
@@ -17272,7 +17310,7 @@ export type V2SessionFormCreateResponses = {
    * Success
    */
   200: {
-    data: FormFormInfoV2 | FormUrlInfoV2
+    data: FormFormInfoV2 | FormUrlInfoV2 | FormIntegrationInfoV2
   }
 }
 
@@ -17310,7 +17348,7 @@ export type V2SessionFormGetResponses = {
    * Success
    */
   200: {
-    data: FormFormInfoV2 | FormUrlInfoV2
+    data: FormFormInfoV2 | FormUrlInfoV2 | FormIntegrationInfoV2
   }
 }
 
@@ -18917,6 +18955,128 @@ export type V2DebugLocationListResponses = {
 
 export type V2DebugLocationListResponse = V2DebugLocationListResponses[keyof V2DebugLocationListResponses]
 
+export type V2WebsearchProviderGetData = {
+  body?: never
+  path?: never
+  query?: {
+    location?: {
+      directory?: string | null
+      workspace?: string | null
+    } | null
+  }
+  url: "/api/websearch/provider"
+}
+
+export type V2WebsearchProviderGetErrors = {
+  /**
+   * InvalidRequestError
+   */
+  400: InvalidRequestErrorV2
+  /**
+   * UnauthorizedError
+   */
+  401: UnauthorizedError
+}
+
+export type V2WebsearchProviderGetError = V2WebsearchProviderGetErrors[keyof V2WebsearchProviderGetErrors]
+
+export type V2WebsearchProviderGetResponses = {
+  /**
+   * Success
+   */
+  200: {
+    location: LocationInfoV2
+    data: string | null
+  }
+}
+
+export type V2WebsearchProviderGetResponse = V2WebsearchProviderGetResponses[keyof V2WebsearchProviderGetResponses]
+
+export type V2WebsearchProviderSelectData = {
+  body: {
+    providerID: string
+  }
+  path?: never
+  query?: {
+    location?: {
+      directory?: string | null
+      workspace?: string | null
+    } | null
+  }
+  url: "/api/websearch/provider"
+}
+
+export type V2WebsearchProviderSelectErrors = {
+  /**
+   * InvalidRequestError
+   */
+  400: InvalidRequestError1 | InvalidRequestErrorV2
+  /**
+   * UnauthorizedError
+   */
+  401: UnauthorizedError
+  /**
+   * ServiceUnavailableError
+   */
+  503: ServiceUnavailableErrorV2
+}
+
+export type V2WebsearchProviderSelectError = V2WebsearchProviderSelectErrors[keyof V2WebsearchProviderSelectErrors]
+
+export type V2WebsearchProviderSelectResponses = {
+  /**
+   * <No Content>
+   */
+  204: void
+}
+
+export type V2WebsearchProviderSelectResponse =
+  V2WebsearchProviderSelectResponses[keyof V2WebsearchProviderSelectResponses]
+
+export type V2WebsearchQueryData = {
+  body: {
+    query: string
+    providerID?: string
+  }
+  path?: never
+  query?: {
+    location?: {
+      directory?: string | null
+      workspace?: string | null
+    } | null
+  }
+  url: "/api/websearch"
+}
+
+export type V2WebsearchQueryErrors = {
+  /**
+   * InvalidRequestError
+   */
+  400: InvalidRequestError1 | InvalidRequestErrorV2
+  /**
+   * UnauthorizedError
+   */
+  401: UnauthorizedError
+  /**
+   * ServiceUnavailableError
+   */
+  503: ServiceUnavailableErrorV2
+}
+
+export type V2WebsearchQueryError = V2WebsearchQueryErrors[keyof V2WebsearchQueryErrors]
+
+export type V2WebsearchQueryResponses = {
+  /**
+   * Success
+   */
+  200: {
+    location: LocationInfoV2
+    data: WebSearchResult
+  }
+}
+
+export type V2WebsearchQueryResponse = V2WebsearchQueryResponses[keyof V2WebsearchQueryResponses]
+
 export type PtyConnectData = {
   body?: never
   path: {

packages/server/src/handlers.ts

@@ -20,6 +20,7 @@ import { QuestionHandler } from "./handlers/question"
 import { ReferenceHandler } from "./handlers/reference"
 import { LocationHandler } from "./handlers/location"
 import { IntegrationHandler } from "./handlers/integration"
+import { WebSearchHandler } from "./handlers/websearch"
 import { McpHandler } from "./handlers/mcp"
 import { CredentialHandler } from "./handlers/credential"
 import { ProjectHandler } from "./handlers/project"
@@ -38,6 +39,7 @@ export const handlers = Layer.mergeAll(
   GenerateHandler,
   ProviderHandler,
   IntegrationHandler,
+  WebSearchHandler,
   McpHandler,
   CredentialHandler,
   ProjectHandler,

packages/server/src/handlers/websearch.ts

@@ -0,0 +1,91 @@
+import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
+import { WebSearch } from "@opencode-ai/core/websearch"
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode-ai/protocol/errors"
+import { Effect } from "effect"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { Api } from "../api"
+import { response } from "../location"
+
+export const WebSearchHandler = HttpApiBuilder.group(Api, "server.websearch", (handlers) =>
+  Effect.gen(function* () {
+    const awaitPlugins = Effect.fn("server.websearch.awaitPlugins")(function* () {
+      const plugins = yield* PluginSupervisor.Service
+      yield* plugins.ready.pipe(
+        Effect.timeoutOrElse({
+          duration: "5 seconds",
+          orElse: () =>
+            Effect.fail(
+              new ServiceUnavailableError({
+                message: "Web search integration initialization timed out",
+                service: "websearch",
+              }),
+            ),
+        }),
+      )
+    })
+    return handlers
+      .handle(
+        "websearch.provider.get",
+        Effect.fn("server.websearch.provider.get")(function* () {
+          const websearch = yield* WebSearch.Service
+          return yield* response(websearch.selected())
+        }),
+      )
+      .handle(
+        "websearch.provider.select",
+        Effect.fn("server.websearch.provider.select")(function* (request) {
+          yield* awaitPlugins()
+          const websearch = yield* WebSearch.Service
+          yield* websearch.select(request.payload.providerID).pipe(
+            Effect.mapError(
+              (error) =>
+                new InvalidRequestError({
+                  message: `Web search provider not found: ${error.providerID}`,
+                  kind: "websearch_provider_not_found",
+                  field: "providerID",
+                }),
+            ),
+          )
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "websearch.query",
+        Effect.fn("server.websearch.query")(function* (request) {
+          yield* awaitPlugins()
+          const websearch = yield* WebSearch.Service
+          return yield* response(
+            websearch.query(request.payload).pipe(
+              Effect.catchTags({
+                "WebSearch.ProviderRequired": () =>
+                  new InvalidRequestError({
+                    message: "Web search provider is required",
+                    kind: "websearch_provider_required",
+                    field: "providerID",
+                  }),
+                "WebSearch.ProviderNotFound": (error) =>
+                  new InvalidRequestError({
+                    message: `Web search provider not found: ${error.providerID}`,
+                    kind: "websearch_provider_not_found",
+                    field: "providerID",
+                  }),
+                "WebSearch.ConnectionRequired": (error) =>
+                  new InvalidRequestError({
+                    message: `Web search provider requires a connection: ${error.providerID}`,
+                    kind: "websearch_connection_required",
+                    field: "providerID",
+                  }),
+                "WebSearch.Cancelled": () =>
+                  new InvalidRequestError({ message: "Web search cancelled", kind: "websearch_cancelled" }),
+                "WebSearch.Request": (error) =>
+                  new ServiceUnavailableError({
+                    message: `Web search request failed: ${error.providerID}`,
+                    service: error.providerID,
+                  }),
+              }),
+            ),
+          )
+        }),
+      )
+  }),
+)

packages/tui/src/component/dialog-integration.tsx

@@ -53,28 +53,47 @@ export function connectionSummary(integration: IntegrationInfo) {
     .join(", ")
 }
 
-export function DialogIntegration(props: { onConnected?: OnIntegrationConnected } = {}) {
+export function DialogIntegration(
+  props: { onConnected?: OnIntegrationConnected; integrationID?: string; connectionOnly?: boolean } = {},
+) {
   const data = useData()
   const dialog = useDialog()
   const { theme } = useTheme()
   const options = createMemo(() =>
-    integrationOptions(data.location.integration.list() ?? []).map((integration) => {
-      const methods = connectMethods(integration)
-      const connected = integration.connections.length > 0
-      return {
-        title: integration.name,
-        value: integration.id,
-        description: methods.length ? undefined : "Environment only",
-        footer: connectionSummary(integration) || undefined,
-        category: integration.id in INTEGRATION_PRIORITY ? "Popular" : "Services",
-        disabled: methods.length === 0,
-        gutter: connected ? () => <text fg={theme.success}>✓</text> : undefined,
-        onSelect: () =>
-          credentialConnections(integration).length
-            ? manageConnections(integration, methods, dialog, props.onConnected)
-            : selectMethod(integration, methods, dialog, props.onConnected),
-      }
-    }),
+    integrationOptions(data.location.integration.list() ?? [])
+      .filter((integration) => props.integrationID === undefined || integration.id === props.integrationID)
+      .map((integration) => {
+        const methods = connectMethods(integration)
+        const connected = integration.connections.length > 0
+        const websearch = integration.websearch
+        const selected = data.location.websearch.provider() === integration.id
+        const credentials = credentialConnections(integration)
+        const description = websearch?.connection === "optional" ? "API key optional" : undefined
+        const category = websearch ? "Web search" : undefined
+        return {
+          title: integration.name,
+          value: integration.id,
+          description: description ?? (methods.length === 0 ? "Environment only" : undefined),
+          footer:
+            [connectionSummary(integration), selected ? "Web search default" : undefined]
+              .filter((value) => value !== undefined && value.length > 0)
+              .join(" · ") || undefined,
+          category: category ?? (integration.id in INTEGRATION_PRIORITY ? "Popular" : "Services"),
+          disabled: methods.length === 0 && !websearch,
+          gutter: connected ? () => <text fg={theme.success}>✓</text> : undefined,
+          onSelect: () => {
+            if (props.connectionOnly) {
+              return credentials.length
+                ? manageConnections(integration, methods, dialog, props.onConnected)
+                : selectMethod(integration, methods, dialog, props.onConnected)
+            }
+            if (websearch) return manageIntegration(integration, methods, websearch, dialog)
+            return credentials.length
+              ? manageConnections(integration, methods, dialog, props.onConnected)
+              : selectMethod(integration, methods, dialog, props.onConnected)
+          },
+        }
+      }),
   )
 
   return (
@@ -90,6 +109,64 @@ export function DialogIntegration(props: { onConnected?: OnIntegrationConnected
   )
 }
 
+function manageIntegration(
+  integration: IntegrationInfo,
+  methods: ConnectMethod[],
+  websearch: NonNullable<IntegrationInfo["websearch"]>,
+  dialog: ReturnType<typeof useDialog>,
+) {
+  const connected = integration.connections.length > 0
+  dialog.replace(() => {
+    const data = useData()
+    const sdk = useSDK()
+    const toast = useToast()
+    const credentials = credentialConnections(integration)
+    const selected = createMemo(() => data.location.websearch.provider() === integration.id)
+    const selectWebSearch = () => {
+      void sdk.api.websearch.provider
+        .select({
+          providerID: integration.id,
+          location: location(data),
+        })
+        .then(async () => {
+          await Promise.all([data.location.integration.refresh(), data.location.websearch.refresh()])
+          toast.show({ variant: "success", message: `${integration.name} is now the web search default` })
+          dialog.clear()
+        })
+        .catch(toast.error)
+    }
+
+    return (
+      <DialogSelect
+        title={integration.name}
+        options={[
+          {
+            title: selected() ? "Web search default" : "Use for web search",
+            value: "websearch",
+            disabled: selected(),
+            onSelect:
+              websearch.connection === "required" && !connected
+                ? () => selectMethod(integration, methods, dialog, selectWebSearch)
+                : selectWebSearch,
+          },
+          ...(methods.length
+            ? [
+                {
+                  title: credentials.length ? "Manage connections" : "Connect",
+                  value: "connect",
+                  onSelect: () =>
+                    credentials.length
+                      ? manageConnections(integration, methods, dialog)
+                      : selectMethod(integration, methods, dialog),
+                },
+              ]
+            : []),
+        ]}
+      />
+    )
+  })
+}
+
 function manageConnections(
   integration: IntegrationInfo,
   methods: ConnectMethod[],
@@ -179,8 +256,8 @@ function KeyMethod(props: {
       placeholder="API key"
       onConfirm={(key) => {
         if (!key) return
-        void sdk.api.integration
-          .connect.key({
+        void sdk.api.integration.connect
+          .key({
             integrationID: props.integration.id,
             location: location(data),
             key,
@@ -218,8 +295,8 @@ function OAuthStarting(props: {
   const toast = useToast()
 
   onMount(() => {
-    void sdk.api.integration
-      .connect.oauth({
+    void sdk.api.integration.connect
+      .oauth({
         integrationID: props.integration.id,
         location: location(data),
         methodID: props.method.id,
@@ -287,8 +364,8 @@ function OAuthAuto(props: {
   }))
 
   const poll = () => {
-    void sdk.api.integration
-      .attempt.status({ attemptID: props.attempt.attemptID, location: location(data) })
+    void sdk.api.integration.attempt
+      .status({ attemptID: props.attempt.attemptID, location: location(data) })
       .then((result) => {
         const status = result.data
         if (status.status === "pending") {
@@ -353,8 +430,8 @@ function OAuthCode(props: {
       placeholder="Authorization code"
       onConfirm={(code) => {
         if (!code) return
-        void sdk.api.integration
-          .attempt.complete({ attemptID: props.attempt.attemptID, location: location(data), code })
+        void sdk.api.integration.attempt
+          .complete({ attemptID: props.attempt.attemptID, location: location(data), code })
           .then(() => {
             settled = true
             return connected(props.integration, data, dialog, toast, props.onConnected)

packages/tui/src/context/data.tsx

@@ -4,26 +4,27 @@
 // Reconnect may re-bootstrap; that is enough. UI and the server own ordering concerns.
 
 import type {
-  AgentV2Info,
-  CommandV2Info,
+  AgentInfo,
+  CommandInfo,
   FormFormInfo,
+  FormIntegrationInfo,
   FormUrlInfo,
   IntegrationInfo,
   LocationRef,
   McpServer,
-  ModelV2Info,
+  ModelInfo,
   PermissionSavedInfo,
   PermissionV2Request,
   ProviderV2Info,
   ReferenceInfo,
-  SessionMessage,
+  SessionMessageInfo,
   SessionMessageAssistant,
   SessionMessageAssistantReasoning,
   SessionMessageAssistantText,
   SessionMessageAssistantTool,
-  SessionV2Info,
+  SessionInfo,
   Shell,
-  SkillV2Info,
+  SkillInfo,
   V2Event,
 } from "@opencode-ai/sdk/v2"
 import { createStore, produce, reconcile } from "solid-js/store"
@@ -36,34 +37,35 @@ export type DataSessionStatus = "idle" | "running"
 const messageIDFromEvent = (eventID: string) => eventID.replace(/^evt_/, "msg_")
 const MESSAGE_PAGE_SIZE = 25
 
-export type FormInfo = FormFormInfo | FormUrlInfo
+export type FormInfo = FormFormInfo | FormUrlInfo | FormIntegrationInfo
 
 // Per-session message timeline plus older-history paging. `items` is ascending;
 // `cursor` is the opaque server cursor for the next older page after a desc first load.
 type SessionMessages = {
-  items: SessionMessage[]
+  items: SessionMessageInfo[]
   cursor?: string
   complete: boolean
   loading: boolean
 }
 
 type LocationData = {
-  agent?: AgentV2Info[]
-  command?: CommandV2Info[]
+  agent?: AgentInfo[]
+  command?: CommandInfo[]
   integration?: IntegrationInfo[]
   mcp?: McpServer[]
-  model?: ModelV2Info[]
+  model?: ModelInfo[]
   provider?: ProviderV2Info[]
   reference?: ReferenceInfo[]
+  websearchProvider?: string | null
   // Currently running shell commands for this location, keyed by shell id. Entries are removed
   // once the command exits or is deleted, so this only ever holds in-flight shells.
   shell?: Record<string, Shell>
-  skill?: SkillV2Info[]
+  skill?: SkillInfo[]
 }
 
 type Data = {
   session: {
-    info: Record<string, SessionV2Info>
+    info: Record<string, SessionInfo>
     // Family index keyed by a family's root (or furthest-known-ancestor when the
     // true root is not yet loaded). The value is a flat deduplicated list of every
     // session ID in that family, including the key itself once its info arrives.
@@ -136,7 +138,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
     }
 
     const message = {
-      update(sessionID: string, fn: (messages: SessionMessage[], index: Map<string, number>) => void) {
+      update(sessionID: string, fn: (messages: SessionMessageInfo[], index: Map<string, number>) => void) {
         setStore(
           "session",
           "message",
@@ -145,28 +147,26 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           }),
         )
       },
-      append(messages: SessionMessage[], index: Map<string, number>, item: SessionMessage) {
+      append(messages: SessionMessageInfo[], index: Map<string, number>, item: SessionMessageInfo) {
         if (index.has(item.id)) return
         index.set(item.id, messages.length)
         messages.push(item)
       },
-      activeAssistant(messages: SessionMessage[]) {
+      activeAssistant(messages: SessionMessageInfo[]) {
         const item = messages.findLast((item) => item.type === "assistant" && !item.time.completed)
         return item?.type === "assistant" ? item : undefined
       },
-      assistant(messages: SessionMessage[], index: Map<string, number>, messageID: string) {
+      assistant(messages: SessionMessageInfo[], index: Map<string, number>, messageID: string) {
         const position = index.get(messageID)
         const item = position === undefined ? undefined : messages[position]
         return item?.type === "assistant" ? item : undefined
       },
-      shell(messages: SessionMessage[], shellID: string) {
-        const item = messages.findLast((item) => item.type === "shell" && item.shell.id === shellID)
+      shell(messages: SessionMessageInfo[], shellID: string) {
+        const item = messages.findLast((item) => item.type === "shell" && item.shellID === shellID)
         return item?.type === "shell" ? item : undefined
       },
-      compaction(messages: SessionMessage[]) {
-        const item = messages.findLast(
-          (item) => item.type === "compaction" && (item.status === "queued" || item.status === "running"),
-        )
+      compaction(messages: SessionMessageInfo[]) {
+        const item = messages.findLast((item) => item.type === "compaction" && item.status === "running")
         return item?.type === "compaction" ? item : undefined
       },
       latestTool(assistant: SessionMessageAssistant | undefined, callID?: string) {
@@ -387,7 +387,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
               type: "synthetic",
-              sessionID: event.data.sessionID,
               text: event.data.text,
               description: event.data.description,
               time: { created: event.created },
@@ -399,7 +398,10 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             message.append(draft, index, {
               id: messageIDFromEvent(event.id),
               type: "shell",
-              shell: event.data.shell,
+              shellID: event.data.shell.id,
+              command: event.data.shell.command,
+              status: event.data.shell.status,
+              exit: event.data.shell.exit,
               time: { created: event.created },
             })
           })
@@ -408,7 +410,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft) => {
             const match = message.shell(draft, event.data.shell.id)
             if (!match) return
-            match.shell = event.data.shell
+            match.command = event.data.shell.command
+            match.status = event.data.shell.status
+            match.exit = event.data.shell.exit
             match.output = event.data.output
             match.time.completed = event.created
           })
@@ -497,7 +501,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               id: event.data.callID,
               name: event.data.name,
               time: { created: event.created },
-              state: { status: "pending", input: "" },
+              state: { status: "streaming", input: "" },
             })
           })
           break
@@ -507,7 +511,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               message.assistant(draft, index, event.data.assistantMessageID),
               event.data.callID,
             )
-            if (match?.state.status === "pending") match.state.input += event.data.delta
+            if (match?.state.status === "streaming") match.state.input += event.data.delta
           })
           break
         case "session.tool.input.ended":
@@ -516,7 +520,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               message.assistant(draft, index, event.data.assistantMessageID),
               event.data.callID,
             )
-            if (match?.state.status === "pending") match.state.input = event.data.text
+            if (match?.state.status === "streaming") match.state.input = event.data.text
           })
           break
         case "session.tool.called":
@@ -568,7 +572,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
               message.assistant(draft, index, event.data.assistantMessageID),
               event.data.callID,
             )
-            if (!match || (match.state.status !== "pending" && match.state.status !== "running")) return
+            if (!match || (match.state.status !== "streaming" && match.state.status !== "running")) return
             match.state = {
               status: "error",
               error: event.data.error,
@@ -623,18 +627,6 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           setSessionStatus(event.data.sessionID, "running")
           break
         case "session.compaction.admitted":
-          message.update(event.data.sessionID, (draft, index) => {
-            if (message.compaction(draft)) return
-            message.append(draft, index, {
-              id: event.data.inputID,
-              type: "compaction",
-              status: "queued",
-              reason: "manual",
-              summary: "",
-              recent: "",
-              time: { created: event.created },
-            })
-          })
           break
         case "session.compaction.started":
           setStore("session", "compaction", event.data.sessionID, "")
@@ -707,10 +699,15 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
           message.update(event.data.sessionID, (draft, index) => {
             const current = message.compaction(draft)
             if (current) {
-              current.status = "completed"
-              current.reason = event.data.reason
-              current.summary = event.data.text
-              current.recent = event.data.recent
+              const position = index.get(current.id)
+              if (position !== undefined)
+                draft[position] = {
+                  ...current,
+                  status: "completed",
+                  reason: event.data.reason,
+                  summary: event.data.text,
+                  recent: event.data.recent,
+                }
               return
             }
             message.append(draft, index, {
@@ -727,9 +724,17 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         case "session.compaction.failed":
           setStore("session", "compaction", event.data.sessionID, undefined)
           setStore("session", "compactionReason", event.data.sessionID, undefined)
-          message.update(event.data.sessionID, (draft) => {
+          message.update(event.data.sessionID, (draft, index) => {
             const current = message.compaction(draft)
-            if (current) current.status = "failed"
+            if (!current) return
+            const position = index.get(current.id)
+            if (position !== undefined)
+              draft[position] = {
+                ...current,
+                status: "failed",
+                reason: event.data.reason,
+                error: event.data.error,
+              }
           })
           break
         case "permission.v2.asked":
@@ -797,6 +802,9 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             result.location.provider.refresh(event.location),
           ])
           break
+        case "config.updated":
+          void result.location.websearch.refresh(event.location)
+          break
         // Authenticating an MCP integration reconnects its server, which emits mcp.status.changed,
         // so the mcp list refreshes here rather than off integration.updated.
         case "mcp.status.changed":
@@ -1041,6 +1049,16 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
             setStore("location", key, { ...store.location[key], reference: mutable(result.data) })
           },
         },
+        websearch: {
+          provider(location?: LocationRef) {
+            return store.location[locationKey(location ?? defaultLocation())]?.websearchProvider ?? undefined
+          },
+          async refresh(ref?: LocationRef) {
+            const result = await sdk.api.websearch.provider.get({ location: locationQuery(ref ?? defaultLocation()) })
+            const key = locationKey(result.location)
+            setStore("location", key, { ...store.location[key], websearchProvider: result.data ?? null })
+          },
+        },
         skill: {
           list(location?: LocationRef) {
             return store.location[locationKey(location ?? defaultLocation())]?.skill
@@ -1101,6 +1119,7 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
         result.location.model.refresh(),
         result.location.provider.refresh(),
         result.location.reference.refresh(),
+        result.location.websearch.refresh(),
         result.location.command.refresh(),
         result.location.skill.refresh(),
         result.shell.refresh(),

packages/tui/src/routes/session/form.tsx

@@ -10,6 +10,8 @@ import { useSDK } from "../../context/sdk"
 import { SplitBorder } from "../../ui/border"
 import { useTuiConfig } from "../../config"
 import { useBindings, useOpencodeModeStack } from "../../keymap"
+import { DialogIntegration } from "../../component/dialog-integration"
+import { useDialog } from "../../ui/dialog"
 
 const FORM_MODE = "form"
 
@@ -131,7 +133,50 @@ function display(field: Field, value: FormValue | undefined) {
 }
 
 export function FormPrompt(props: { form: FormInfo }) {
-  return props.form.mode === "url" ? <UrlPrompt form={props.form} /> : <FieldsPrompt form={props.form} />
+  if (props.form.mode === "url") return <UrlPrompt form={props.form} />
+  if (props.form.mode === "integration") return <IntegrationPrompt form={props.form} />
+  return <FieldsPrompt form={props.form} />
+}
+
+function IntegrationPrompt(props: { form: FormInfo & { mode: "integration" } }) {
+  const sdk = useSDK()
+  const dialog = useDialog()
+  const { theme } = useTheme()
+  let settled = false
+
+  onMount(() => {
+    dialog.replace(
+      () => (
+        <DialogIntegration
+          integrationID={props.form.integrationID}
+          connectionOnly
+          onConnected={() => {
+            settled = true
+            dialog.clear()
+            void sdk.api.form.reply({ sessionID: props.form.sessionID, formID: props.form.id, answer: {} })
+          }}
+        />
+      ),
+      () => {
+        if (settled) return
+        void sdk.api.form.cancel({ sessionID: props.form.sessionID, formID: props.form.id })
+      },
+    )
+  })
+
+  return (
+    <box
+      backgroundColor={theme.backgroundPanel}
+      border={["left"]}
+      borderColor={theme.accent}
+      customBorderChars={SplitBorder.customBorderChars}
+    >
+      <box gap={1} paddingLeft={2} paddingRight={3} paddingTop={1} paddingBottom={1}>
+        <text fg={theme.text}>{props.form.title ?? "Connect integration"}</text>
+        <text fg={theme.textMuted}>Complete the connection dialog to continue.</text>
+      </box>
+    </box>
+  )
 }
 
 function UrlPrompt(props: { form: FormInfo & { mode: "url" } }) {

packages/tui/src/routes/session/index.tsx

@@ -204,7 +204,7 @@ export function Session() {
     return messages().filter((message) => {
       if (boundary && message.id >= boundary) return false
       if (data.session.input.has(route.sessionID, message.id)) return true
-      return message.type === "compaction" && (message.status === "queued" || message.status === "running")
+      return message.type === "compaction" && message.status === "running"
     })
   })
 
@@ -2381,9 +2381,18 @@ function WebFetch(props: ToolProps) {
 }
 
 function WebSearch(props: ToolProps) {
+  const data = useData()
+  const [provider, setProvider] = createSignal(
+    data.location.websearch.provider() ?? stringValue(props.metadata.provider),
+  )
+  createEffect(() => {
+    if (provider()) return
+    const next = data.location.websearch.provider()
+    if (next) setProvider(next)
+  })
   return (
     <InlineTool icon="◈" pending="Searching web..." complete={stringValue(props.input.query)} part={props.part}>
-      {webSearchProviderLabel(props.metadata.provider)} "{stringValue(props.input.query)}"{" "}
+      {webSearchProviderLabel(provider())} "{stringValue(props.input.query)}"{" "}
       <Show when={numberValue(props.metadata.numResults)}>({numberValue(props.metadata.numResults)} results)</Show>
     </InlineTool>
   )

packages/tui/src/routes/session/rows.ts

@@ -1,4 +1,4 @@
-import type { SessionMessage, SessionMessageAssistant } from "@opencode-ai/sdk/v2"
+import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/sdk/v2"
 import { createEffect, on, onCleanup, type Accessor } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { useData } from "../../context/data"
@@ -29,8 +29,7 @@ export function createSessionRows(sessionID: Accessor<string>) {
     const inputs = data.session.input.list(sessionID())
     const pending = new Set(inputs)
     for (const message of data.session.message.list(sessionID())) {
-      if (message.type === "compaction" && (message.status === "queued" || message.status === "running"))
-        pending.add(message.id)
+      if (message.type === "compaction" && message.status === "running") pending.add(message.id)
     }
     return pending
   }
@@ -197,7 +196,7 @@ export function createSessionRows(sessionID: Accessor<string>) {
   return rows
 }
 
-export function reduceSessionRows(messages: SessionMessage[]) {
+export function reduceSessionRows(messages: SessionMessageInfo[]) {
   return messages.reduce<SessionRow[]>((rows, message) => {
     if (message.type !== "assistant") {
       if (message.type === "synthetic" && !message.description?.trim()) return rows

packages/tui/test/cli/tui/data.test.tsx

@@ -161,7 +161,7 @@ test("pages older messages through nested message state", async () => {
 
   try {
     await data.session.message.refresh(sessionID)
-    expect(pages).toEqual([{ limit: "50", order: "desc", cursor: null }])
+    expect(pages).toEqual([{ limit: "25", order: "desc", cursor: null }])
     expect(data.session.message.ids(sessionID)).toEqual(first.toReversed().map((message) => message.id))
     expect(data.session.message.cursor(sessionID)).toBe("cursor-older")
     expect(data.session.message.complete(sessionID)).toBe(false)
@@ -169,8 +169,8 @@ test("pages older messages through nested message state", async () => {
 
     await data.session.message.more(sessionID)
     expect(pages).toEqual([
-      { limit: "50", order: "desc", cursor: null },
-      { limit: "50", order: null, cursor: "cursor-older" },
+      { limit: "25", order: "desc", cursor: null },
+      { limit: "25", order: null, cursor: "cursor-older" },
     ])
     expect(data.session.message.ids(sessionID)[0]).toBe("msg_1")
     expect(data.session.message.ids(sessionID)).toHaveLength(51)

packages/tui/test/fixture/tui-sdk.ts

@@ -69,7 +69,8 @@ export type FetchHandler = (url: URL) => Response | Promise<Response> | undefine
 export function createFetch(override?: FetchHandler, events?: ReturnType<typeof createEventStream>) {
   const session = [] as URL[]
   const fetch = (async (input: RequestInfo | URL) => {
-    const url = new URL(input instanceof Request ? input.url : String(input))
+    const request = input instanceof Request ? input : new Request(input)
+    const url = new URL(request.url)
     if (url.pathname === "/session") session.push(url)
     const overridden = await override?.(url)
     if (overridden) return overridden
@@ -117,6 +118,10 @@ export function createFetch(override?: FetchHandler, events?: ReturnType<typeof
       })
     if (url.pathname === "/api/reference")
       return json({ location: { directory, project: { id: "proj_test", directory } }, data: [] })
+    if (url.pathname === "/api/websearch/provider") {
+      if (request.method === "POST") return new Response(null, { status: 204 })
+      return json({ location: { directory, project: { id: "proj_test", directory } }, data: null })
+    }
     if (url.pathname === "/provider") return json({ all: [], default: {}, connected: [] })
     if (url.pathname === "/session") return json([])
     if (url.pathname === "/vcs") return json({ branch: "main" })