Merge remote-tracking branch 'origin/v2' into websocket-headers

chore: correct websocket changeset
fix(core): prefer websocket with request hooks
2026-08-18 13:49:25 -04:00 · 2026-08-18 22:23:43 +05:30 · 2026-08-18 18:37:55 +05:30 · 2026-08-18 18:28:08 +05:30
55 changed files with 465 additions and 546 deletions
@@ -0,0 +1,6 @@
+---
+"@opencode-ai/plugin": patch
+"@opencode-ai/core": patch
+---
+
+Add transport-neutral Session model request hooks and provider-scoped hook registration so eligible OpenAI Responses requests can prefer WebSocket without bypassing HTTP-only middleware.
@@ -275,36 +275,15 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
        Spec.make("stop", { description: "Stop the background server" }),
        Spec.make("get", {
          description: "Get service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env"), Argument.optional),
-            name: Argument.string("name").pipe(
-              Argument.withDescription("Environment variable name"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key").pipe(Argument.optional) },
        }),
        Spec.make("set", {
          description: "Set service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env")),
-            value: Argument.string("value").pipe(
-              Argument.withDescription("Setting value or environment variable name"),
-            ),
-            nestedValue: Argument.string("env-value").pipe(
-              Argument.withDescription("Environment variable value"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key"), value: Argument.string("value") },
        }),
        Spec.make("unset", {
          description: "Unset service configuration",
-          params: {
-            key: Argument.string("key").pipe(Argument.withDescription("Service setting or env")),
-            name: Argument.string("name").pipe(
-              Argument.withDescription("Environment variable name"),
-              Argument.optional,
-            ),
-          },
+          params: { key: Argument.string("key") },
        }),
      ],
    }),
@@ -7,8 +7,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
  Commands.commands.service.commands.get,
  Effect.fn("cli.service.get")(function* (input) {
-    process.stdout.write(
-      (yield* ServiceConfig.get(Option.getOrUndefined(input.key), Option.getOrUndefined(input.name))) + EOL,
-    )
+    process.stdout.write((yield* ServiceConfig.get(Option.getOrUndefined(input.key))) + EOL)
  }),
 )
@@ -1,4 +1,4 @@
-import { Effect, Option } from "effect"
+import { Effect } from "effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
@@ -6,6 +6,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
  Commands.commands.service.commands.set,
  Effect.fn("cli.service.set")(function* (input) {
-    yield* ServiceConfig.set(input.key, input.value, Option.getOrUndefined(input.nestedValue))
+    yield* ServiceConfig.set(input.key, input.value)
  }),
 )
@@ -1,4 +1,4 @@
-import { Effect, Option } from "effect"
+import { Effect } from "effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
@@ -6,6 +6,6 @@ import { ServiceConfig } from "../../../services/service-config"
 export default Runtime.handler(
  Commands.commands.service.commands.unset,
  Effect.fn("cli.service.unset")(function* (input) {
-    yield* ServiceConfig.unset(input.key, Option.getOrUndefined(input.name))
+    yield* ServiceConfig.unset(input.key)
  }),
 )
@@ -15,11 +15,10 @@ export const Info = Schema.Struct({
  hostname: Schema.optional(Schema.String),
  port: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(65_535))),
  password: Schema.optional(Schema.String),
-  env: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 })
 export type Info = typeof Info.Type

-const keys = ["hostname", "port", "password", "env"] as const
+const keys = ["hostname", "port", "password"] as const
 type Key = (typeof keys)[number]

 const decodeInfo = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
@@ -77,7 +76,7 @@ export const migrateConfig = Effect.fnUntraced(function* (legacy: string, file:
 })

 function configKey(key: string): Key {
-  if (key === "hostname" || key === "port" || key === "password" || key === "env") return key
+  if (key === "hostname" || key === "port" || key === "password") return key
  throw new Error(`Unknown service config key: ${key}`)
 }

@@ -105,7 +104,6 @@ export const options = Effect.fnUntraced(function* (input: { readonly checkVersi
  return {
    file,
    version: input.checkVersion ? OPENCODE_VERSION : undefined,
-    env: (yield* read()).env,
    command: [
      ...selfCommand(),
      "serve",
@@ -143,14 +141,12 @@ export const password = Effect.fn("cli.service-config.password")(function* (valu
  return next
 })

-export const get = Effect.fn("cli.service-config.get")(function* (key?: string, name?: string) {
+export const get = Effect.fn("cli.service-config.get")(function* (key?: string) {
  if (key === undefined) {
    const { password: _password, ...safe } = yield* read()
    return JSON.stringify(safe, null, 2)
  }
-  const selected = configKey(key)
-  if (selected !== "env" && name !== undefined) throw new Error(`Usage: opencode service get ${selected}`)
-  switch (selected) {
+  switch (configKey(key)) {
    case "hostname": {
      return (yield* read()).hostname ?? ""
    }
@@ -161,19 +157,12 @@ export const get = Effect.fn("cli.service-config.get")(function* (key?: string,
    case "password": {
      return yield* password()
    }
-    case "env": {
-      const env = (yield* read()).env ?? {}
-      return name === undefined ? JSON.stringify(env, null, 2) : (env[name] ?? "")
-    }
  }
  throw new Error(`Unknown service config key: ${key}`)
 })

-export const set = Effect.fn("cli.service-config.set")(function* (key: string, value: string, nestedValue?: string) {
-  const selected = configKey(key)
-  if (selected !== "env" && nestedValue !== undefined)
-    throw new Error(`Usage: opencode service set ${selected} <value>`)
-  switch (selected) {
+export const set = Effect.fn("cli.service-config.set")(function* (key: string, value: string) {
+  switch (configKey(key)) {
    case "hostname": {
      yield* Service.stop(yield* options())
      yield* write({ ...(yield* read()), hostname: value })
@@ -191,20 +180,11 @@ export const set = Effect.fn("cli.service-config.set")(function* (key: string, v
      yield* password(value)
      return
    }
-    case "env": {
-      if (nestedValue === undefined) throw new Error("Usage: opencode service set env <key> <value>")
-      yield* Service.stop(yield* options())
-      const existing = yield* read()
-      yield* write({ ...existing, env: { ...existing.env, [value]: nestedValue } })
-      return
-    }
  }
 })

-export const unset = Effect.fn("cli.service-config.unset")(function* (key: string, name?: string) {
-  const selected = configKey(key)
-  if (selected !== "env" && name !== undefined) throw new Error(`Usage: opencode service unset ${selected}`)
-  switch (selected) {
+export const unset = Effect.fn("cli.service-config.unset")(function* (key: string) {
+  switch (configKey(key)) {
    case "hostname": {
      yield* Service.stop(yield* options())
      const { hostname: _hostname, ...next } = yield* read()
@@ -223,15 +203,6 @@ export const unset = Effect.fn("cli.service-config.unset")(function* (key: strin
      yield* write(next)
      return
    }
-    case "env": {
-      if (name === undefined) throw new Error("Usage: opencode service unset env <key>")
-      yield* Service.stop(yield* options())
-      const existing = yield* read()
-      const { [name]: _removed, ...env } = existing.env ?? {}
-      const { env: _existingEnv, ...rest } = existing
-      yield* write(Object.keys(env).length === 0 ? rest : { ...rest, env })
-      return
-    }
  }
 })

@@ -60,44 +60,6 @@ test("local channel stores service config with the local service filename", asyn
  }
 })

-test("service config manages environment variables", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-env-"))
-  const layer = Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })
-  try {
-    await Effect.runPromise(
-      ServiceConfig.set("env", "OPENCODE_SERVICE_ENV_TEST", "configured").pipe(
-        Effect.provide(layer),
-        Effect.provide(NodeFileSystem.layer),
-      ),
-    )
-    expect(
-      await Effect.runPromise(
-        ServiceConfig.get("env", "OPENCODE_SERVICE_ENV_TEST").pipe(
-          Effect.provide(layer),
-          Effect.provide(NodeFileSystem.layer),
-        ),
-      ),
-    ).toBe("configured")
-    expect(
-      (
-        await Effect.runPromise(
-          ServiceConfig.options().pipe(Effect.provide(layer), Effect.provide(NodeFileSystem.layer)),
-        )
-      ).env,
-    ).toEqual({ OPENCODE_SERVICE_ENV_TEST: "configured" })
-
-    await Effect.runPromise(
-      ServiceConfig.unset("env", "OPENCODE_SERVICE_ENV_TEST").pipe(
-        Effect.provide(layer),
-        Effect.provide(NodeFileSystem.layer),
-      ),
-    )
-    expect(await Bun.file(path.join(root, "config", "service-local.json")).json()).toEqual({})
-  } finally {
-    await fs.rm(root, { recursive: true, force: true })
-  }
-})
-
 test("service filenames share release channels and identify preview channels", () => {
  expect(ServiceConfig.filename("latest")).toBe("service.json")
  expect(ServiceConfig.filename("dev")).toBe("service.json")
@@ -71,7 +71,7 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
    if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
    return yield* Effect.try({
      try: () => {
-        return spawnServiceContender(command, args, options.env)
+        return spawnServiceContender(command, args)
      },
      catch: (cause) => new Error("Failed to start server", { cause }),
    })
@@ -51,7 +51,7 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
    if (command === undefined) throw new Error("Missing service command")
    try {
-      return spawnServiceContender(command, args, options.env)
+      return spawnServiceContender(command, args)
    } catch (cause) {
      throw new Error("Failed to start server", { cause })
    }
@@ -10,16 +10,8 @@ export type ServiceContender = {

 const stderrLimit = 8 * 1024

-export function spawnServiceContender(
-  command: string,
-  args: ReadonlyArray<string>,
-  env?: Readonly<Record<string, string>>,
-): ServiceContender {
-  const child = spawn(command, args, {
-    detached: true,
-    stdio: ["ignore", "ignore", "pipe"],
-    env: { ...process.env, ...env },
-  })
+export function spawnServiceContender(command: string, args: ReadonlyArray<string>): ServiceContender {
+  const child = spawn(command, args, { detached: true, stdio: ["ignore", "ignore", "pipe"] })
  let error: Error | undefined
  let closed = false
  let stderr = Buffer.alloc(0)
@@ -28,8 +28,6 @@ export type EnsureReason = "missing" | "version-mismatch"
 export type EnsureOptions = DiscoverOptions & {
  /** Service command and arguments. Defaults to `opencode serve --service`. */
  readonly command?: ReadonlyArray<string>
-  /** Environment variables added to the inherited service process environment. */
-  readonly env?: Readonly<Record<string, string>>
  /** Called once before spawning a new service process. */
  readonly onStart?: (reason: EnsureReason, previousVersion?: string) => void
 }
@@ -11,8 +11,6 @@ if (mode === "record-start") {
  await writeFile(registration + ".started", "")
  process.exit(1)
 }
-if (mode === "environment")
-  await writeFile(registration + ".environment", process.env.OPENCODE_SERVICE_ENV_TEST ?? "")
 if (mode === "signal") process.kill(process.pid, process.platform === "win32" ? "SIGTERM" : "SIGKILL")

 if (mode === "delayed" || mode === "delayed-failed" || mode === "coordinated" || mode === "coordinated-failed-loser") {
@@ -59,26 +59,6 @@ test("ensures a missing service with native promises", async () => {
  }
 })

-test("adds configured environment variables with native promises", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await ensure({
-    file: registration,
-    version: "test",
-    command: [process.execPath, fixture, registration, "environment"],
-    env: { OPENCODE_SERVICE_ENV_TEST: "configured" },
-  })
-  const info = await Bun.file(registration).json()
-
-  try {
-    expect(endpoint.url).toBe(info.url)
-    expect(await Bun.file(registration + ".environment").text()).toBe("configured")
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-})
-
 test("waits for a live contender when another native contender fails", async () => {
  const directory = await temp()
  const registration = join(directory, "service.json")
@@ -68,28 +68,6 @@ test("reuses a compatible registered service", async () => {
  expect(existing.exitCode).toBe(null)
 })

-test("adds configured environment variables when starting a service", async () => {
-  const directory = await temp()
-  const registration = join(directory, "service.json")
-  const endpoint = await run(
-    ensure({
-      file: registration,
-      version: "test",
-      command: [process.execPath, fixture, registration, "environment"],
-      env: { OPENCODE_SERVICE_ENV_TEST: "configured" },
-    }),
-  )
-  const info = await Bun.file(registration).json()
-
-  try {
-    expect(endpoint.url).toBe(info.url)
-    expect(await Bun.file(registration + ".environment").text()).toBe("configured")
-  } finally {
-    process.kill(info.pid, "SIGTERM")
-    await waitForExit(info.pid)
-  }
-})
-
 test("replaces an incompatible registered service", async () => {
  const directory = await temp()
  const registration = join(directory, "service.json")
@@ -109,7 +109,7 @@ const layer = Layer.effect(
      get: Effect.fn("Agent.get")(function* (id) {
        return state.get().agents.get(id)
      }),
-      resolve: Effect.fnUntraced(function* (id) {
+      resolve: Effect.fn("Agent.resolve")(function* (id) {
        if (id !== undefined) return state.get().agents.get(ID.make(id))
        return selectedDefault()
      }),
@@ -426,7 +426,7 @@ export const layer = (options?: Options) =>
      )

      return Service.of({
-        entries: Effect.fnUntraced(function* () {
+        entries: Effect.fn("Config.entries")(function* () {
          return configs
        }),
        update,
@@ -120,13 +120,9 @@ export class EffectSQLiteSession<TRelations extends AnyRelations> extends SQLite

  private execute(query: Query, params: unknown[], method: SQLiteExecuteMethod | "values") {
    const statement = this.client.unsafe(query.sql, params)
-    if (method === "values") return statement.values.pipe(Effect.withTracerEnabled(false))
-    if (method === "get")
-      return statement.withoutTransform.pipe(
-        Effect.map((rows) => rows[0]),
-        Effect.withTracerEnabled(false),
-      )
-    return statement.withoutTransform.pipe(Effect.withTracerEnabled(false))
+    if (method === "values") return statement.values
+    if (method === "get") return statement.withoutTransform.pipe(Effect.map((rows) => rows[0]))
+    return statement.withoutTransform
  }

  private isInTransaction() {
@@ -138,7 +138,7 @@ export const make = Effect.gen(function* () {
    scope: yield* Scope.Scope,
  }

-  const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
+  const settle = Effect.fn("Job.settle")(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
    const completed_at = yield* Clock.currentTimeMillis
    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
      const job = jobs.get(id)
@@ -170,7 +170,7 @@ export const make = Effect.gen(function* () {
    return result.info
  })

-  const fork = Effect.fnUntraced(function* (
+  const fork = Effect.fn("Job.fork")(function* (
    scope: Scope.Scope,
    id: string,
    token: object,
@@ -192,7 +192,7 @@ export const make = Effect.gen(function* () {
    return snapshot(job)
  })

-  const start: Interface["start"] = Effect.fnUntraced(function* (input) {
+  const start: Interface["start"] = Effect.fn("Job.start")(function* (input) {
    return yield* Effect.uninterruptibleMask((restore) =>
      Effect.gen(function* () {
        const id = input.id ?? Identifier.ascending("job")
@@ -247,7 +247,7 @@ export const make = Effect.gen(function* () {
    return { info: snapshot(job), timedOut: true }
  })

-  const removeBlock = Effect.fnUntraced(function* (input: BlockInput) {
+  const removeBlock = Effect.fn("Job.removeBlock")(function* (input: BlockInput) {
    yield* SynchronizedRef.update(state.jobs, (jobs) => {
      const job = jobs.get(input.id)
      if (!job || job.info.status !== "running" || job.isBackgrounded) return jobs
@@ -258,7 +258,7 @@ export const make = Effect.gen(function* () {
    })
  })

-  const block: Interface["block"] = Effect.fnUntraced(function* (input) {
+  const block: Interface["block"] = Effect.fn("Job.block")(function* (input) {
    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [BlockStart, Map<string, Active>] => {
      const job = jobs.get(input.id)
      if (!job) return [{ type: "missing" }, jobs]
@@ -65,7 +65,7 @@ const layer = Layer.effect(
    const fs = yield* FSUtil.Service
    const location = yield* Location.Service

-    const resolve = Effect.fnUntraced(function* (input: ResolveInput) {
+    const resolve = Effect.fn("LocationMutation.resolve")(function* (input: ResolveInput) {
      const absolute = path.resolve(location.directory, input.path)
      if (FSUtil.contains(location.directory, absolute)) {
        return {
@@ -152,14 +152,14 @@ const layer = Layer.effect(
      )
    })

-    const configured = Effect.fnUntraced(function* (sessionID: SessionSchema.ID, agentID?: Agent.ID) {
+    const configured = Effect.fn("Permission.configured")(function* (sessionID: SessionSchema.ID, agentID?: Agent.ID) {
      const session = yield* sessions.get(sessionID)
      if (!session) return yield* new SessionErrors.NotFoundError({ sessionID })
      const agent = yield* agents.resolve(agentID ?? session.agent)
      return agent?.permissions ?? missingAgentPermissions
    })

-    const allowsAll = Effect.fnUntraced(function* (input: {
+    const allowsAll = Effect.fn("Permission.allowsAll")(function* (input: {
      readonly sessionID: SessionSchema.ID
      readonly action: string
      readonly agent?: Agent.ID
@@ -39,7 +39,7 @@ const layer = Layer.effect(
  Effect.gen(function* () {
    const { db } = yield* Database.Service

-    const list = Effect.fnUntraced(function* (input?: ListInput) {
+    const list = Effect.fn("PermissionSaved.list")(function* (input?: ListInput) {
      const rows = yield* db
        .select()
        .from(PermissionTable)
@@ -4,6 +4,7 @@ import type { AISDKHooks } from "@opencode-ai/plugin/effect/aisdk"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import type { ShellHooks } from "@opencode-ai/plugin/effect/shell"
 import type { ToolFailures, ToolHooks } from "@opencode-ai/plugin/effect/tool"
+import type { ModelHookOptions } from "@opencode-ai/plugin/effect/registration"
 import { Context, Effect, Layer, Scope } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { State } from "../state.js"
@@ -26,16 +27,26 @@ interface Failures extends Record<keyof Domains, unknown> {
 }

 type Callback<Event, Error> = (event: Event) => Effect.Effect<void, Error>
+type Entry = { readonly callback: Function; readonly options?: ModelHookOptions }
+
+const eventProviderID = (event: unknown) => {
+  if (typeof event !== "object" || event === null || !("model" in event)) return undefined
+  const model = event.model
+  if (typeof model !== "object" || model === null || !("providerID" in model)) return undefined
+  return typeof model.providerID === "string" ? model.providerID : undefined
+}

 export interface Interface {
  readonly has: <Domain extends keyof Domains>(
    domain: Domain,
    name: keyof Domains[Domain] & keyof Failures[Domain],
+    providerID?: string,
  ) => Effect.Effect<boolean>
  readonly register: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
    domain: Domain,
    name: Name,
    callback: Callback<Domains[Domain][Name], Failures[Domain][Name]>,
+    options?: ModelHookOptions,
  ) => Effect.Effect<State.Registration, never, Scope.Scope>
  readonly trigger: <Domain extends keyof Domains, Name extends keyof Domains[Domain] & keyof Failures[Domain]>(
    domain: Domain,
@@ -49,36 +60,47 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Pl
 const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    const callbacks = new Map<string, Function[]>()
+    const callbacks = new Map<string, Entry[]>()
    const key = (domain: keyof Domains, name: PropertyKey) => `${domain}.${String(name)}`

-    const register: Interface["register"] = Effect.fn("PluginHooks.register")(function* (domain, name, callback) {
-      const scope = yield* Scope.Scope
-      const id = key(domain, name)
-      let active = true
-      callbacks.set(id, [...(callbacks.get(id) ?? []), callback])
-      const dispose = Effect.sync(() => {
-        if (!active) return
-        active = false
-        const next = (callbacks.get(id) ?? []).filter((item) => item !== callback)
-        if (next.length === 0) callbacks.delete(id)
-        else callbacks.set(id, next)
-      })
-      yield* Scope.addFinalizer(scope, dispose)
-      return { dispose }
-    })
+    const register: Interface["register"] = Effect.fn("PluginHooks.register")(
+      function* (domain, name, callback, options) {
+        const scope = yield* Scope.Scope
+        const id = key(domain, name)
+        let active = true
+        const entry = { callback, options }
+        callbacks.set(id, [...(callbacks.get(id) ?? []), entry])
+        const dispose = Effect.sync(() => {
+          if (!active) return
+          active = false
+          const next = (callbacks.get(id) ?? []).filter((item) => item !== entry)
+          if (next.length === 0) callbacks.delete(id)
+          else callbacks.set(id, next)
+        })
+        yield* Scope.addFinalizer(scope, dispose)
+        return { dispose }
+      },
+    )

-    const trigger: Interface["trigger"] = Effect.fnUntraced(function* (domain, name, event) {
-      for (const callback of callbacks.get(key(domain, name)) ?? []) {
-        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(callback, undefined, [
-          event,
-        ])
+    const trigger: Interface["trigger"] = Effect.fn("PluginHooks.trigger")(function* (domain, name, event) {
+      for (const entry of callbacks.get(key(domain, name)) ?? []) {
+        if (entry.options?.providerID !== undefined && entry.options.providerID !== eventProviderID(event)) continue
+        const result: Effect.Effect<void, Failures[typeof domain][typeof name]> = Reflect.apply(
+          entry.callback,
+          undefined,
+          [event],
+        )
        yield* result
      }
      return event
    })

-    const has: Interface["has"] = (domain, name) => Effect.sync(() => callbacks.has(key(domain, name)))
+    const has: Interface["has"] = (domain, name, providerID) =>
+      Effect.sync(() =>
+        (callbacks.get(key(domain, name)) ?? []).some(
+          (entry) => entry.options?.providerID === undefined || entry.options.providerID === providerID,
+        ),
+      )

    return Service.of({ has, register, trigger })
  }),
@@ -104,9 +104,10 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    aisdk: {
-      hook: (name, callback) => {
+      hook: (name, callback, options) => {
        if (name === "sdk") {
          return aisdk.hook.sdk((event) => {
+            if (options?.providerID !== undefined && options.providerID !== event.model.providerID) return Effect.void
            const output = {
              model: mutable(event.model),
              package: event.package,
@@ -119,6 +120,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
          })
        }
        return aisdk.hook.language((event) => {
+          if (options?.providerID !== undefined && options.providerID !== event.model.providerID) return Effect.void
          const output = {
            model: mutable(event.model),
            options: event.options,
@@ -382,7 +384,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
        }),
    },
    session: {
-      hook: (name, callback) => hooks.register("session", name, callback),
+      hook: (name, callback, options) => hooks.register("session", name, callback, options),
      create: (input) =>
        runtime.session.create({
          id: input?.id,
@@ -241,19 +241,22 @@ export const GithubCopilotPlugin = define({
        evt.sdk = mod.createOpenaiCompatible(evt.options)
      }),
    )
-    yield* ctx.session.hook("http.request", (evt) =>
-      Effect.gen(function* () {
-        if (evt.model.providerID !== Provider.ID.githubCopilot) return
-        if (evt.agent === Agent.ID.make("title"))
-          evt.request.headers.set("X-Interaction-Type", "conversation-background")
-        if (evt.agent === Agent.ID.make("compaction"))
-          evt.request.headers.set("X-Interaction-Type", "conversation-compaction")
-        const token = evt.request.headers.get("x-api-key")
-        if (!token) return
-        const text = yield* Effect.promise(() => evt.request.clone().text())
-        const body = Option.getOrUndefined(decodeBody(text))
-        applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true)
-      }),
+    yield* ctx.session.hook(
+      "http.request",
+      (evt) =>
+        Effect.gen(function* () {
+          if (evt.model.providerID !== Provider.ID.githubCopilot) return
+          if (evt.agent === Agent.ID.make("title"))
+            evt.request.headers.set("X-Interaction-Type", "conversation-background")
+          if (evt.agent === Agent.ID.make("compaction"))
+            evt.request.headers.set("X-Interaction-Type", "conversation-compaction")
+          const token = evt.request.headers.get("x-api-key")
+          if (!token) return
+          const text = yield* Effect.promise(() => evt.request.clone().text())
+          const body = Option.getOrUndefined(decodeBody(text))
+          applyHeaders(evt.request.headers, token, ctx.app, requestMetadata(evt.request.url, body), true)
+        }),
+      { providerID: Provider.ID.githubCopilot },
    )
    yield* ctx.aisdk.hook(
      "language",
@@ -5,7 +5,6 @@ import { App } from "../../app.js"
 import { Credential } from "../../credential.js"
 import { Bus } from "../../bus.js"
 import { Integration } from "../../integration.js"
-import { Model } from "../../model.js"
 import { OauthCallbackPage } from "../../oauth/page.js"
 import { Provider } from "../../provider.js"
 import type { PluginInternal } from "../internal.js"
@@ -230,15 +229,17 @@ export const OpenAIPlugin = define({
        })
      }
    })
-    yield* ctx.session.hook("http.request", (evt) =>
-      Effect.sync(() => {
-        if (!chatgpt || evt.model.providerID !== Provider.ID.openai) return
-        const url = new URL(evt.request.url)
-        evt.request.headers.set("originator", "opencode")
-        evt.request.headers.set("session-id", evt.sessionID)
-        if (url.origin !== "https://api.openai.com") return
-        evt.request = new Request(`${codexBaseURL}${url.pathname.replace(/^\/v1/, "")}${url.search}`, evt.request)
-      }),
+    yield* ctx.session.hook(
+      "model.request",
+      (evt) =>
+        Effect.sync(() => {
+          if (!chatgpt) return
+          if (evt.baseURL && URL.canParse(evt.baseURL) && new URL(evt.baseURL).origin === "https://api.openai.com")
+            evt.baseURL = codexBaseURL
+          evt.headers.originator = "opencode"
+          evt.headers["session-id"] = evt.sessionID
+        }),
+      { providerID: Provider.ID.openai },
    )
    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
    yield* bus.subscribe(Integration.Event.ConnectionUpdated).pipe(
@@ -12,6 +12,7 @@ import { llmClient } from "../effect/app-node-platform.js"
 import { SessionEvent } from "./event.js"
 import type { SessionMessage } from "./message.js"
 import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { App } from "../app.js"
@@ -270,23 +271,25 @@ const make = (dependencies: Dependencies) => {
          })
        : Effect.void,
    )
+    const request = yield* SessionModelHook.apply(
+      dependencies.hooks,
+      { sessionID: plan.session.id, agent: Agent.ID.make("compaction"), model: plan.ref },
+      LLM.request({
+        model: plan.model,
+        promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
+        http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
+        messages: [Message.user(plan.prompt)],
+        tools: [],
+      }),
+    )
    yield* dependencies.llm
-      .stream(
-        LLM.request({
-          model: plan.model,
-          promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
-          http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
-          messages: [Message.user(plan.prompt)],
-          tools: [],
+      .stream(request, {
+        http: SessionModelHttp.middleware(dependencies.hooks, {
+          sessionID: plan.session.id,
+          agent: Agent.ID.make("compaction"),
+          model: plan.ref,
        }),
-        {
-          http: SessionModelHttp.middleware(dependencies.hooks, {
-            sessionID: plan.session.id,
-            agent: Agent.ID.make("compaction"),
-            model: plan.ref,
-          }),
-        },
-      )
+      })
      .pipe(
        Stream.runForEach((event) => {
          if (LLMEvent.is.providerError(event))
@@ -11,6 +11,7 @@ import { SessionContext } from "./context.js"
 import { SessionGenerate } from "./generate.js"
 import { SessionHistory } from "./history.js"
 import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { SessionRunnerModel } from "./runner/model.js"
@@ -71,7 +72,9 @@ export const layer = Layer.effect(
          providerID: model.ref.providerID,
          modelID: model.ref.id,
        })
-        const response = yield* llm.generate(
+        const request = yield* SessionModelHook.apply(
+          hooks,
+          { sessionID: selection.session.id, agent: selection.agent.id, model: model.ref },
          LLM.request({
            model: model.model,
            http: { headers: SessionModelHeaders.make(selection.session, app) },
@@ -80,14 +83,14 @@ export const layer = Layer.effect(
            messages: contextEvent.messages,
            tools: hookedTools,
          }),
-          {
-            http: SessionModelHttp.middleware(hooks, {
-              sessionID: selection.session.id,
-              agent: selection.agent.id,
-              model: model.ref,
-            }),
-          },
        )
+        const response = yield* llm.generate(request, {
+          http: SessionModelHttp.middleware(hooks, {
+            sessionID: selection.session.id,
+            agent: selection.agent.id,
+            model: model.ref,
+          }),
+        })
        yield* Effect.logInfo("session generation usage diagnostic", { usage: response.usage })
        return response.text
      }),
@@ -0,0 +1,34 @@
+export * as SessionModelHook from "./model-hook.js"
+
+import { HttpOptions, LanguageModel, LLMRequest } from "@opencode-ai/ai"
+import type { Agent } from "@opencode-ai/schema/agent"
+import type { Model } from "@opencode-ai/schema/model"
+import type { Session } from "@opencode-ai/schema/session"
+import { Effect } from "effect"
+import { PluginHooks } from "../plugin/hooks.js"
+
+export const apply = (
+  hooks: PluginHooks.Interface,
+  input: { readonly sessionID: Session.ID; readonly agent: Agent.ID; readonly model: Model.Ref },
+  request: LLMRequest,
+) =>
+  Effect.gen(function* () {
+    const currentBaseURL = request.model.route.endpoint.baseURL
+    const event = yield* hooks.trigger("session", "model.request", {
+      ...input,
+      baseURL: typeof currentBaseURL === "string" ? currentBaseURL : undefined,
+      headers: { ...request.http?.headers },
+    })
+    const route =
+      event.baseURL !== undefined && event.baseURL !== currentBaseURL
+        ? request.model.route.with({ endpoint: { baseURL: event.baseURL } })
+        : request.model.route
+    return LLMRequest.update(request, {
+      model: route === request.model.route ? request.model : LanguageModel.update(request.model, { route }),
+      http: new HttpOptions({
+        body: request.http?.body,
+        headers: Object.keys(event.headers).length === 0 ? undefined : event.headers,
+        query: request.http?.query,
+      }),
+    })
+  })
@@ -14,6 +14,7 @@ import { QuestionTool } from "../tool/plugin/question.js"
 import { Tool } from "../tool.js"
 import { SessionContext } from "./context.js"
 import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionModelTransport } from "./model-transport.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
@@ -226,20 +227,25 @@ export const layer = Layer.effect(
          return [[name, { ...tool, description: definition.description, inputSchema: definition.input }] as const]
        }),
      )
-      const request = LLM.request({
-        model,
-        http: {
-          headers: SessionModelHeaders.make(session, app),
-        },
-        // TODO: Persist cache lineage so nested forks reuse the root session's cache key.
-        promptCacheKey: SessionPromptCacheKey.make(session.fork?.sessionID ?? session.id),
-        system: context.system,
-        messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
-        tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
-        toolChoice: stepLimitReached ? "none" : undefined,
-      })
+      const request = yield* SessionModelHook.apply(
+        hooks,
+        { sessionID: session.id, agent: agent.id, model: resolved.ref },
+        LLM.request({
+          model,
+          http: {
+            headers: SessionModelHeaders.make(session, app),
+          },
+          // TODO: Persist cache lineage so nested forks reuse the root session's cache key.
+          promptCacheKey: SessionPromptCacheKey.make(session.fork?.sessionID ?? session.id),
+          system: context.system,
+          messages: boundImages(unsupportedParts(context.messages, resolved.capabilities)),
+          tools: Array.from(hooked, ([name, tool]) => ({ ...tool, name })),
+          toolChoice: stepLimitReached ? "none" : undefined,
+        }),
+      )
      const webSocketEligible =
-        !(yield* hooks.has("session", "http.request")) && !(yield* hooks.has("session", "http.response"))
+        !(yield* hooks.has("session", "http.request", resolved.ref.providerID)) &&
+        !(yield* hooks.has("session", "http.response", resolved.ref.providerID))
      const http = webSocketEligible
        ? undefined
        : SessionModelHttp.middleware(hooks, {
@@ -252,7 +258,7 @@ export const layer = Layer.effect(
        ...(webSocket &&
        webSocketEligible &&
        resolved.ref.providerID === Provider.ID.openai &&
-        model.route.id === "openai-responses"
+        request.model.route.id === "openai-responses"
          ? { webSocket: transport.bind(session.id) }
          : {}),
      }
@@ -54,7 +54,7 @@ const layer = Layer.effect(
    const decodeMessage = Schema.decodeUnknownEffect(SessionMessage.Info)

    return Service.of({
-      get: Effect.fnUntraced(function* (sessionID) {
+      get: Effect.fn("SessionStore.get")(function* (sessionID) {
        const row = yield* db.select().from(SessionTable).where(eq(SessionTable.id, sessionID)).get().pipe(Effect.orDie)
        return row ? fromRow(row) : undefined
      }),
@@ -14,6 +14,7 @@ import { PluginHooks } from "../plugin/hooks.js"
 import { SessionEvent } from "./event.js"
 import { SessionHistory } from "./history.js"
 import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
 import { SessionModelHttp } from "./model-http.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
@@ -80,23 +81,25 @@ const make = (dependencies: Dependencies) => {
          })
        : Effect.void,
    )
+    const request = yield* SessionModelHook.apply(
+      dependencies.hooks,
+      { sessionID: session.id, agent: agent.id, model: resolved.ref },
+      LLM.request({
+        model: resolved.model,
+        http: { headers: SessionModelHeaders.make(session, dependencies.app) },
+        system: agent.system,
+        messages: [Message.user(firstUser.text)],
+        tools: [],
+      }),
+    )
    const streamed = yield* dependencies.llm
-      .stream(
-        LLM.request({
-          model: resolved.model,
-          http: { headers: SessionModelHeaders.make(session, dependencies.app) },
-          system: agent.system,
-          messages: [Message.user(firstUser.text)],
-          tools: [],
+      .stream(request, {
+        http: SessionModelHttp.middleware(dependencies.hooks, {
+          sessionID: session.id,
+          agent: agent.id,
+          model: resolved.ref,
        }),
-        {
-          http: SessionModelHttp.middleware(dependencies.hooks, {
-            sessionID: session.id,
-            agent: agent.id,
-            model: resolved.ref,
-          }),
-        },
-      )
+      })
      .pipe(
        Stream.runForEach((event) => {
          if (LLMEvent.is.providerError(event)) failed = true
@@ -101,7 +101,7 @@ export const layer = (options?: ShellSelect.Options) =>
        }),
      )

-      const require = Effect.fnUntraced(function* (id: Shell.ID) {
+      const require = Effect.fn("Shell.require")(function* (id: Shell.ID) {
        const session = sessions.get(id)
        if (!session) return yield* new NotFoundError({ id })
        return session
@@ -153,7 +153,7 @@ export const layer = (options?: ShellSelect.Options) =>

      const name = () => resolve().pipe(Effect.map(ShellSelect.name))

-      const output = Effect.fnUntraced(function* (id: Shell.ID, input?: Shell.OutputInput) {
+      const output = Effect.fn("Shell.output")(function* (id: Shell.ID, input?: Shell.OutputInput) {
        const session = yield* require(id)
        const cursor = input?.cursor ?? 0
        const limit = input?.limit ?? 65536
@@ -153,7 +153,7 @@ const ARITY: Record<string, number> = {
  "yarn run": 3,
 }

-export const scan = Effect.fnUntraced(function* (
+export const scan = Effect.fn("ShellParse.scan")(function* (
  command: string,
  shell: string,
  cwd: string,
@@ -163,7 +163,7 @@ export const scan = Effect.fnUntraced(function* (
  return yield* scanLegacy(command, shell, cwd)
 })

-const scanLegacy = Effect.fnUntraced(function* (command: string, shell: string, cwd: string) {
+const scanLegacy = Effect.fn("ShellParse.scanLegacy")(function* (command: string, shell: string, cwd: string) {
  const parsers = yield* Effect.promise(load)
  const powershell = ShellSelect.ps(shell)
  const tree = (powershell ? parsers.ps : parsers.bash).parse(command)
@@ -97,7 +97,10 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
  const materialize = Effect.fnUntraced(function* () {
    const next = options.initial()
    const api = options.draft(next)
-    for (const transform of transforms) yield* apply(transform.run, api)
+    for (const transform of transforms)
+      yield* apply(transform.run, api).pipe(
+        Effect.withSpan("State.reload.update", { attributes: { state: options.name ?? "anonymous" } }),
+      )
    yield* commit(next)
  })

@@ -51,7 +51,7 @@ const layer = Layer.effect(
    const global = yield* Global.Service
    const directory = path.join(global.data, DIRECTORY)

-    const truncate = Effect.fnUntraced(function* (result: Result) {
+    const truncate = Effect.fn("ToolOutput.truncate")(function* (result: Result) {
      if (result.metadata?.truncated !== undefined) return result
      const content =
        typeof result.content === "string" ? [{ type: "text" as const, text: result.content }] : (result.content ?? [])
@@ -50,7 +50,7 @@ const layer = Layer.effect(
    const image = yield* Image.Service

    type NormalizedItem = Tool.Content | "decode" | "size"
-    const normalizeImages = Effect.fnUntraced(function* (content: ReadonlyArray<Tool.Content>) {
+    const normalizeImages = Effect.fn("Tool.normalizeImages")(function* (content: ReadonlyArray<Tool.Content>) {
      const normalized = yield* Effect.forEach(content, (item): Effect.Effect<NormalizedItem> => {
        if (item.type !== "file" || !item.mime.startsWith("image/")) return Effect.succeed(item)
        const base64 = /^data:[^,]*;base64,(.*)$/s.exec(item.uri)?.[1]
@@ -208,7 +208,7 @@ export const Plugin = {
              )
              yield* context.progress({ shellID: info.id })

-              const captureShell = Effect.fnUntraced(function* () {
+              const captureShell = Effect.fn("ShellTool.captureShell")(function* () {
                const configured = Config.latest(yield* config.entries(), "tool_output")
                const maxLines = configured?.max_lines ?? ToolOutput.MAX_LINES
                const maxBytes = configured?.max_bytes ?? ToolOutput.MAX_BYTES
@@ -228,7 +228,7 @@ export const Plugin = {
                }
              })

-              const settleShell = Effect.fnUntraced(function* () {
+              const settleShell = Effect.fn("ShellTool.settleShell")(function* () {
                const final = yield* shell.wait(info.id)
                const capture = yield* captureShell()

@@ -4,6 +4,7 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema, Semaphore } from "effect"
 import { HttpClientError } from "effect/unstable/http"
+import { Config } from "../../config.js"
 import { Form } from "../../form.js"
 import { Permission } from "../../permission.js"
 import { WebSearch } from "../../websearch.js"
@@ -29,6 +30,7 @@ export const Plugin = {
  effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
    const permission = yield* Permission.Service
    const forms = yield* Form.Service
+    const config = yield* Config.Service
    const websearch = yield* WebSearch.Service

    yield* ctx.tool
@@ -95,7 +97,9 @@ export const Plugin = {
                          if (response.status === "cancelled")
                            return yield* Effect.fail(new Error("Web search cancelled"))
                          if (response.answer.choice === "disable") {
-                            yield* websearch.select(false)
+                            yield* config.update((draft) => {
+                              draft.websearch = false
+                            })
                            return yield* new WebSearch.DisabledError()
                          }
                          const selection =
@@ -127,7 +131,11 @@ export const Plugin = {
                            (providerID !== "random" && !providers.some((provider) => provider.id === providerID))
                          )
                            return yield* new WebSearch.ProviderRequiredError()
-                          yield* websearch.select(providerID === "random" ? "random" : WebSearch.ID.make(providerID))
+                          yield* config.update((draft) => {
+                            draft.websearch = {
+                              provider: providerID === "random" ? "random" : WebSearch.ID.make(providerID),
+                            }
+                          })
                          if (providerID !== "random") return WebSearch.ID.make(providerID)
                          return providers[Math.floor(Math.random() * providers.length)]?.id
                        }),
@@ -198,10 +206,7 @@ export const Plugin = {

    yield* ctx.session.hook("context", (event) =>
      Effect.gen(function* () {
-        const disabled = yield* websearch.default().pipe(
-          Effect.as(false),
-          Effect.catchTag("WebSearch.Disabled", () => Effect.succeed(true)),
-        )
+        const disabled = Config.latest(yield* config.entries(), "websearch") === false
        if (disabled) delete event.tools[name]
      }),
    )
@@ -1,10 +1,9 @@
 export * as WebSearch from "./websearch.js"

 import { WebSearch } from "@opencode-ai/schema/websearch"
-import { Context, Effect, Layer, Option, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "./bus.js"
-import { KV } from "./kv.js"
 import { State } from "./state.js"

 export const ID = WebSearch.ID
@@ -25,10 +24,6 @@ export type Result = WebSearch.Result
 export const Response = WebSearch.Response
 export type Response = WebSearch.Response

-export const ProviderKey = "websearch:provider"
-export const Selection = Schema.Union([ID, Schema.Literal("random"), Schema.Literal(false)])
-export type Selection = typeof Selection.Type
-
 export interface ProviderImplementation extends Provider {
  readonly execute: (input: ProviderInput) => Effect.Effect<readonly Result[], unknown>
 }
@@ -54,7 +49,6 @@ export type Error = ProviderRequiredError | ProviderNotFoundError | DisabledErro
 export interface Interface extends State.Transformable<Draft> {
  readonly providers: () => Effect.Effect<readonly Provider[]>
  readonly default: () => Effect.Effect<Provider | undefined, DisabledError>
-  readonly select: (selection: Selection) => Effect.Effect<void>
  readonly query: (input: Input) => Effect.Effect<Response, Error>
 }

@@ -62,14 +56,14 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/We

 type Data = {
  readonly providers: Map<ID, ProviderImplementation>
-  selection?: Selection
+  selection?: ID | "random" | false
 }

 export type Draft = {
  add: (provider: ProviderImplementation) => void
  default: {
-    get: () => Selection | undefined
-    set: (selection: Selection) => void
+    get: () => ID | "random" | false | undefined
+    set: (selection: ID | "random" | false) => void
  }
 }

@@ -77,7 +71,6 @@ const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const bus = yield* Bus.Service
-    const kv = yield* KV.Service
    const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result))
    const state = State.create<Data, Draft>({
      initial: () => ({ providers: new Map() }),
@@ -98,16 +91,12 @@ const layer = Layer.effect(

    const defaultProvider = Effect.fn("WebSearch.default")(function* () {
      const data = state.get()
-      const stored = data.selection === undefined ? yield* kv.get(ProviderKey) : undefined
-      const decoded = Schema.decodeUnknownOption(Selection)(stored)
-      if (stored !== undefined && Option.isNone(decoded)) yield* kv.remove(ProviderKey)
-      const selection = data.selection ?? Option.getOrUndefined(decoded)
-      if (selection === false) return yield* new DisabledError()
-      if (selection === "random") {
+      if (data.selection === false) return yield* new DisabledError()
+      if (data.selection === "random") {
        const providers = Array.from(data.providers.values())
        return providers[Math.floor(Math.random() * providers.length)]
      }
-      return selection ? data.providers.get(selection) : undefined
+      return data.selection ? data.providers.get(data.selection) : undefined
    })

    const resolve = Effect.fn("WebSearch.resolve")(function* (input: Input) {
@@ -131,9 +120,6 @@ const layer = Layer.effect(
        const provider = yield* defaultProvider()
        return provider && { id: provider.id, name: provider.name }
      }),
-      select: Effect.fn("WebSearch.select")(function* (selection) {
-        yield* kv.set(ProviderKey, selection)
-      }),
      query: Effect.fn("WebSearch.query")(function* (input) {
        const provider = yield* resolve(input)
        const results = yield* provider.execute({ query: input.query }).pipe(
@@ -149,5 +135,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
  service: Service,
  layer,
-  deps: [Bus.node, KV.node],
+  deps: [Bus.node],
 })
@@ -6,7 +6,7 @@ import { expect, test } from "bun:test"
 import { SqliteClient } from "@effect/sql-sqlite-bun"
 import { eq, sql } from "drizzle-orm"
 import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core"
-import { Effect, Tracer } from "effect"
+import { Effect } from "effect"
 import type { SqlClient as SqlClientService } from "effect/unstable/sql/SqlClient"
 import { isSqlError } from "effect/unstable/sql/SqlError"
 import { EffectDrizzleSqlite } from "@opencode-ai/core/database/drizzle"
@@ -49,31 +49,6 @@ test("selects rows through Effect-yieldable query builders", async () => {
  )
 })

-test("suppresses statement spans", async () => {
-  const spans: Tracer.NativeSpan[] = []
-  const tracer = Tracer.make({
-    span(options) {
-      const span = new Tracer.NativeSpan(options)
-      spans.push(span)
-      return span
-    },
-  })
-
-  await Effect.runPromise(
-    Effect.gen(function* () {
-      const db = yield* makeDb
-      yield* db.transaction((tx) => tx.insert(users).values({ name: "Grace" }))
-      yield* db.select().from(users)
-    }).pipe(
-      Effect.provideService(Tracer.Tracer, tracer),
-      Effect.provide(SqliteClient.layer({ filename: ":memory:", disableWAL: true })),
-      Effect.scoped,
-    ),
-  )
-
-  expect(spans.map((span) => span.name)).not.toContain("sql.execute")
-})
-
 test("commits successful transactions", async () => {
  await run(
    Effect.gen(function* () {
@@ -320,10 +320,14 @@ describe("fromPromise", () => {
        define({
          id: "promise-session-http",
          setup: async (ctx) => {
-            await ctx.session.hook("http.request", (event) => {
-              event.request = new Request("https://provider.test/changed", event.request)
-              event.request.headers.set("x-hook", "promise")
-            })
+            await ctx.session.hook(
+              "http.request",
+              (event) => {
+                event.request = new Request("https://provider.test/changed", event.request)
+                event.request.headers.set("x-hook", "promise")
+              },
+              { providerID: "test" },
+            )
            await ctx.session.hook("http.response", async (event) => {
              event.response = new Response(`${await event.response.text()}-response`, {
                status: event.response.status,
@@ -342,6 +346,11 @@ describe("fromPromise", () => {
        ...context,
        request: new Request("https://provider.test", { method: "POST", body: "payload" }),
      })
+      const ignored = yield* hooks.trigger("session", "http.request", {
+        ...context,
+        model: Model.Ref.make({ providerID: Provider.ID.make("other"), id: Model.ID.make("model") }),
+        request: new Request("https://other.test"),
+      })
      const response = yield* hooks.trigger("session", "http.response", {
        ...context,
        request: request.request,
@@ -349,6 +358,9 @@ describe("fromPromise", () => {
      })

      expect(request.request.url).toBe("https://provider.test/changed")
+      expect(ignored.request.url).toBe("https://other.test/")
+      expect(yield* hooks.has("session", "http.request", Provider.ID.make("test"))).toBe(true)
+      expect(yield* hooks.has("session", "http.request", Provider.ID.make("other"))).toBe(false)
      expect(yield* Effect.promise(() => response.response.text())).toBe("promise-response")
    }),
  )
@@ -1,17 +1,25 @@
 import { Money } from "@opencode-ai/schema/money"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Session } from "@opencode-ai/schema/session"
+import { OpenAIResponses } from "@opencode-ai/ai/protocols/openai-responses"
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
+import { ConfigProvider, DateTime, Effect } from "effect"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Credential } from "@opencode-ai/core/credential"
 import { Integration } from "@opencode-ai/core/integration"
+import { Location } from "@opencode-ai/core/location"
 import { Model } from "@opencode-ai/core/model"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
+import { GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
 import { OpenAIPlugin } from "@opencode-ai/core/plugin/provider/openai"
+import { Project } from "@opencode-ai/core/project"
 import { Provider } from "@opencode-ai/core/provider"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { SessionModelRequest } from "@opencode-ai/core/session/model-request"
+import { SessionModelTransport } from "@opencode-ai/core/session/model-transport"
+import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"

@@ -24,19 +32,33 @@ const addPlugin = Effect.fn(function* () {
  yield* OpenAIPlugin.effect(host).pipe(Effect.provideService(Integration.Service, integrations))
 })

+const addGithubCopilotPlugin = Effect.fn(function* () {
+  const plugin = yield* Plugin.Service
+  const host = yield* PluginHost.make(plugin)
+  yield* GithubCopilotPlugin.effect(host)
+})
+
 function required<T>(value: T | undefined): T {
  if (value === undefined) throw new Error("Expected value")
  return value
 }

-const http = Effect.fn(function* (providerID: Provider.ID, url: string) {
-  const event = yield* (yield* PluginHooks.Service).trigger("session", "http.request", {
+const request = Effect.fn(function* (providerID: Provider.ID, baseURL: string) {
+  const hooks = yield* PluginHooks.Service
+  const event = yield* hooks.trigger("session", "model.request", {
    sessionID: Session.ID.make("ses_test"),
    agent: Agent.ID.make("build"),
    model: Model.Ref.make({ providerID, id: Model.ID.make("gpt-5.5") }),
-    request: new Request(url, { method: "POST", body: "{}" }),
+    baseURL,
+    headers: {},
  })
-  return { url: event.request.url, headers: Object.fromEntries(event.request.headers.entries()) }
+  return {
+    baseURL: event.baseURL,
+    headers: event.headers,
+    hasHttpHooks:
+      (yield* hooks.has("session", "http.request", providerID)) ||
+      (yield* hooks.has("session", "http.response", providerID)),
+  }
 })

 describe("OpenAIPlugin", () => {
@@ -110,18 +132,19 @@ describe("OpenAIPlugin", () => {
      })
      yield* addPlugin()

-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
-      const custom = yield* http(Provider.ID.make("custom-openai"), "https://custom.example/v1/responses")
-      const proxy = yield* http(Provider.ID.openai, "https://proxy.example/v1/responses?region=us")
+      const direct = yield* request(Provider.ID.openai, "https://api.openai.com/v1")
+      const custom = yield* request(Provider.ID.make("custom-openai"), "https://custom.example/v1")
+      const proxy = yield* request(Provider.ID.openai, "https://proxy.example/v1?region=us")

      const provider = required(yield* catalog.provider.get(Provider.ID.openai))
      expect(provider.package).toBe("@opencode-ai/ai/providers/openai")
      expect(provider.settings).toMatchObject({ baseURL: "https://chatgpt.com/backend-api/codex" })
      expect(provider.headers).toMatchObject({ originator: "opencode", "chatgpt-account-id": "acct_123" })
-      expect(request.url).toBe("https://chatgpt.com/backend-api/codex/responses")
-      expect(request.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
+      expect(direct.baseURL).toBe("https://chatgpt.com/backend-api/codex")
+      expect(direct.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
+      expect(direct.hasHttpHooks).toBe(false)
      expect(custom.headers).not.toHaveProperty("originator")
-      expect(proxy.url).toBe("https://proxy.example/v1/responses?region=us")
+      expect(proxy.baseURL).toBe("https://proxy.example/v1?region=us")
      expect(proxy.headers).toMatchObject({ originator: "opencode", "session-id": "ses_test" })
      const eligible = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
      expect(eligible.package).toBe("@opencode-ai/ai/providers/openai")
@@ -167,16 +190,77 @@ describe("OpenAIPlugin", () => {
      })
      yield* addPlugin()

-      const request = yield* http(Provider.ID.openai, "https://api.openai.com/v1/responses")
+      const direct = yield* request(Provider.ID.openai, "https://api.openai.com/v1")

      const provider = required(yield* catalog.provider.get(Provider.ID.openai))
      const model = required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.5")))
      expect(model.package).toBe("@opencode-ai/ai/providers/openai")
      expect(model.enabled).toBe(true)
      expect(model.limit).toEqual({ context: 1_050_000, input: 922_000, output: 128_000 })
-      expect(request.headers).not.toHaveProperty("originator")
+      expect(direct.headers).not.toHaveProperty("originator")
+      expect(direct.hasHttpHooks).toBe(false)
      expect(provider.headers).not.toHaveProperty("originator")
      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(true)
    }),
  )
+
+  it.effect("selects WebSocket with the built-in provider hooks enabled", () =>
+    Effect.gen(function* () {
+      const credentials = yield* Credential.Service
+      yield* credentials.create({
+        integrationID: Integration.ID.make("openai"),
+        value: Credential.Key.make({ type: "key", key: "sk-test" }),
+      })
+      yield* addPlugin()
+      yield* addGithubCopilotPlugin()
+      const executor = { execute: () => Effect.die("unused WebSocket execution") }
+      const transport = SessionModelTransport.Service.of({
+        bind: () => executor,
+        close: () => Effect.void,
+        closeAll: Effect.void,
+      })
+      const sessionID = Session.ID.make("ses_websocket_hooks")
+      const agentID = Agent.ID.make("build")
+      const agent = Agent.Info.make(Agent.Info.default(agentID))
+      const model = SessionRunnerModel.resolved(OpenAIResponses.route.model({ id: "gpt-5.5" }), {
+        capabilities: { tools: true, input: ["text"], output: ["text"] },
+        cost: [],
+      })
+      const program = Effect.gen(function* () {
+        const requests = yield* SessionModelRequest.Service
+        return yield* requests.prepare({
+          context: {
+            session: Session.Info.make({
+              id: sessionID,
+              projectID: Project.ID.global,
+              cost: Money.USD.zero,
+              tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+              time: { created: DateTime.makeUnsafe(0), updated: DateTime.makeUnsafe(0) },
+              location: Location.Ref.make({ directory: AbsolutePath.make("/project") }),
+            }),
+            agent: { id: agentID, info: agent },
+            model,
+            initial: "",
+            messages: [],
+            tools: { definitions: [], execute: () => Effect.die("unused tool execution") },
+          },
+          step: 1,
+        })
+      }).pipe(
+        Effect.provide(SessionModelRequest.layer),
+        Effect.provideService(SessionModelTransport.Service, transport),
+        Effect.provide(
+          ConfigProvider.layer(
+            ConfigProvider.fromEnv({ env: { OPENCODE_EXPERIMENTAL_OPENAI_RESPONSES_WEBSOCKET: "true" } }),
+          ),
+        ),
+      )
+
+      const prepared = yield* program
+
+      expect(prepared.webSocketEligible).toBe(true)
+      expect(prepared.options.webSocket).toBe(executor)
+      expect(prepared.options.http).toBeUndefined()
+    }),
+  )
 })
@@ -291,18 +291,25 @@ it.effect(
      instruction = "Changed context"
      const before = yield* durableState(db, sessionID)
      const hooks = yield* PluginHooks.Service
+      let modelRequestHook = false
      yield* hooks.register("session", "context", (event) =>
        Effect.sync(() => {
          event.system = [SystemPart.make("Hooked system"), ...event.system]
          if (event.tools.lookup) event.tools.lookup.description = "Hooked lookup"
        }),
      )
+      yield* hooks.register("session", "model.request", () =>
+        Effect.sync(() => {
+          modelRequestHook = true
+        }),
+      )

      const generate = yield* SessionGenerate.Service
      const result = yield* generate.generate({ sessionID, prompt: "Summarize privately" })

      expect(result).toBe("Transient answer")
      expect(requests).toHaveLength(1)
+      expect(modelRequestHook).toBe(true)
      expect(hasHttpMiddleware).toBe(true)
      expect(requests[0]?.model).toBe(model)
      expect(requests[0]?.system[0]?.text).toBe("Hooked system")
@@ -1020,6 +1020,36 @@ describe("SessionRunnerLLM", () => {
    }),
  )

+  it.effect("keeps WebSocket eligibility after model request hooks", () =>
+    Effect.gen(function* () {
+      yield* setup
+      const hooks = yield* PluginHooks.Service
+      yield* hooks.register("session", "model.request", (event) =>
+        Effect.sync(() => {
+          event.headers["x-model-request-hook"] = "active"
+        }),
+      )
+      yield* hooks.register("session", "http.request", () => Effect.die("Other-provider HTTP hook should not apply"), {
+        providerID: Provider.ID.githubCopilot,
+      })
+      const context = yield* SessionContext.Service
+      const modelRequests = yield* SessionModelRequest.Service
+      const selected = yield* context.select(sessionID)
+      const database = yield* Database.Service
+      const bus = yield* Bus.Service
+      yield* InstructionState.prepare(database.db, bus, selected.instructions, sessionID)
+
+      const prepared = yield* modelRequests.prepare({
+        context: yield* context.load(selected),
+        step: 1,
+      })
+
+      expect(prepared.request.http?.headers?.["x-model-request-hook"]).toBe("active")
+      expect(prepared.webSocketEligible).toBe(true)
+      expect(prepared.options.http).toBeUndefined()
+    }),
+  )
+
  it.effect("forces HTTP and triggers active request and response hooks once", () =>
    Effect.gen(function* () {
      yield* setup
@@ -29,7 +29,7 @@ const webSearchToolNode = makeLocationNode({
      yield* registerToolPlugin(WebSearchTool.Plugin, { websearch: webSearchHost(websearch) })
    }),
  ),
-  deps: [Tool.node, Permission.node, WebSearch.node, Form.node],
+  deps: [Tool.node, Permission.node, WebSearch.node, Form.node, Config.node],
 })

 const sessionID = Session.ID.make("ses_websearch_test")
@@ -93,7 +93,6 @@ const websearch = Layer.succeed(
        if (selection === false) return yield* new WebSearch.DisabledError()
        return selection ? providers.find((provider) => provider.id === selection) : undefined
      }),
-    select: (next) => Effect.sync(() => (selection = next)),
    query: (input) =>
      Effect.gen(function* () {
        queries.push(input)
@@ -3,11 +3,10 @@ import { Effect, Exit, Scope } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
-import { KV } from "@opencode-ai/core/kv"
 import { WebSearch } from "@opencode-ai/core/websearch"
 import { testEffect } from "./lib/effect"

-const it = testEffect(AppNodeBuilder.build(LayerNode.group([WebSearch.node, Bus.node, KV.node])))
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([WebSearch.node, Bus.node])))

 const register = (id: string) =>
  Effect.gen(function* () {
@@ -81,31 +80,6 @@ describe("WebSearch", () => {
    }),
  )

-  it.effect("persists the selected provider in KV", () =>
-    Effect.gen(function* () {
-      const parallel = yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-      const kv = yield* KV.Service
-
-      yield* websearch.select(parallel.providerID)
-
-      expect(yield* kv.get(WebSearch.ProviderKey)).toBe(parallel.providerID)
-      expect((yield* websearch.query({ query: "remembered" })).providerID).toBe(parallel.providerID)
-    }),
-  )
-
-  it.effect("keeps config transforms above the persisted selection", () =>
-    Effect.gen(function* () {
-      const exa = yield* register("exa")
-      const parallel = yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-      yield* websearch.select(parallel.providerID)
-      yield* websearch.transform((draft) => draft.default.set(exa.providerID))
-
-      expect((yield* websearch.query({ query: "configured" })).providerID).toBe(exa.providerID)
-    }),
-  )
-
  it.effect("chooses a registered provider for random selection", () =>
    Effect.gen(function* () {
      yield* register("exa")
@@ -1,6 +1,6 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import type { Model } from "@opencode-ai/schema/model"
-import type { Hooks } from "./registration.js"
+import type { ModelHooks } from "./registration.js"

 export interface AISDKHooks {
  sdk: {
@@ -18,5 +18,5 @@ export interface AISDKHooks {
 }

 export interface AISDKDomain {
-  readonly hook: Hooks<AISDKHooks>
+  readonly hook: ModelHooks<AISDKHooks>
 }
@@ -4,6 +4,11 @@ export interface Registration {
  readonly dispose: Effect.Effect<void>
 }

+export interface ModelHookOptions {
+  /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+  readonly providerID?: string
+}
+
 export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
  Name extends keyof Spec,
 >(
@@ -11,4 +16,12 @@ export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<ke
  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
 ) => Effect.Effect<Registration, never, Scope.Scope>

+export type ModelHooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <
+  Name extends keyof Spec,
+>(
+  name: Name,
+  callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>,
+  options?: ModelHookOptions,
+) => Effect.Effect<Registration, never, Scope.Scope>
+
 export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>
@@ -4,7 +4,7 @@ import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
 import type { JsonSchema } from "effect"
-import type { Hooks } from "./registration.js"
+import type { ModelHooks } from "./registration.js"

 export interface SessionContext {
  readonly sessionID: Session.ID
@@ -15,6 +15,14 @@ export interface SessionContext {
  tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }

+export interface SessionModelRequest {
+  readonly sessionID: Session.ID
+  readonly agent: Agent.ID
+  readonly model: Model.Ref
+  baseURL?: string
+  headers: Record<string, string>
+}
+
 export interface SessionHttpRequest {
  readonly sessionID: Session.ID
  readonly agent: Agent.ID
@@ -32,6 +40,7 @@ export interface SessionHttpResponse {

 export interface SessionHooks {
  readonly context: SessionContext
+  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
 }
@@ -40,5 +49,5 @@ export type SessionDomain = Pick<
  SessionApi<unknown>,
  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
 > & {
-  readonly hook: Hooks<SessionHooks>
+  readonly hook: ModelHooks<SessionHooks>
 }
@@ -129,8 +129,10 @@ export function fromPromise(plugin: Plugin) {
            reload: () => run(host.agent.reload()),
          },
          aisdk: {
-            hook: (name, callback) =>
-              register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+            hook: (name, callback, options) =>
+              register(
+                host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options),
+              ),
          },
          catalog: {
            provider: {
@@ -294,8 +296,10 @@ export function fromPromise(plugin: Plugin) {
              ),
          },
          session: {
-            hook: (name, callback) =>
-              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+            hook: (name, callback, options) =>
+              register(
+                host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))), options),
+              ),
            create: adaptApiMethod(SessionEndpoints["session.create"], host.session.create),
            get: adaptApiMethod(SessionEndpoints["session.get"], host.session.get),
            prompt: adaptApiMethod(SessionEndpoints["session.prompt"], host.session.prompt),
@@ -1,6 +1,6 @@
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import type { Model } from "@opencode-ai/schema/model"
-import type { Hooks } from "./registration.js"
+import type { ModelHooks } from "./registration.js"

 export interface AISDKHooks {
  sdk: {
@@ -18,5 +18,5 @@ export interface AISDKHooks {
 }

 export interface AISDKDomain {
-  readonly hook: Hooks<AISDKHooks>
+  readonly hook: ModelHooks<AISDKHooks>
 }
@@ -2,9 +2,20 @@ export interface Registration {
  readonly dispose: () => Promise<void>
 }

+export interface ModelHookOptions {
+  /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
+  readonly providerID?: string
+}
+
 export type Hooks<Spec> = <Name extends keyof Spec>(
  name: Name,
  callback: (input: Spec[Name]) => Promise<void> | void,
 ) => Promise<Registration>

+export type ModelHooks<Spec> = <Name extends keyof Spec>(
+  name: Name,
+  callback: (input: Spec[Name]) => Promise<void> | void,
+  options?: ModelHookOptions,
+) => Promise<Registration>
+
 export type Transform<Input> = (callback: (input: Input) => void) => Promise<Registration>
@@ -4,7 +4,7 @@ import type { Agent } from "@opencode-ai/schema/agent"
 import type { Model } from "@opencode-ai/schema/model"
 import type { Session } from "@opencode-ai/schema/session"
 import type { JsonSchema } from "effect"
-import type { Hooks } from "./registration.js"
+import type { ModelHooks } from "./registration.js"

 export interface SessionContext {
  readonly sessionID: Session.ID
@@ -15,6 +15,14 @@ export interface SessionContext {
  tools: Record<string, { description: string; input: JsonSchema.JsonSchema }>
 }

+export interface SessionModelRequest {
+  readonly sessionID: Session.ID
+  readonly agent: Agent.ID
+  readonly model: Model.Ref
+  baseURL?: string
+  headers: Record<string, string>
+}
+
 export interface SessionHttpRequest {
  readonly sessionID: Session.ID
  readonly agent: Agent.ID
@@ -32,6 +40,7 @@ export interface SessionHttpResponse {

 export interface SessionHooks {
  readonly context: SessionContext
+  readonly "model.request": SessionModelRequest
  readonly "http.request": SessionHttpRequest
  readonly "http.response": SessionHttpResponse
 }
@@ -40,5 +49,5 @@ export type SessionDomain = Pick<
  SessionApi,
  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
 > & {
-  readonly hook: Hooks<SessionHooks>
+  readonly hook: ModelHooks<SessionHooks>
 }
@@ -23,7 +23,6 @@ import { useStorage } from "../context/storage"
 import { useConfig } from "../config"
 import { withTimestampedFallback } from "@opencode-ai/util/session-title-fallback"
 import { projectName } from "../util/project"
-import { useLocation } from "../context/location"

 export function DialogSessionList() {
  const dialog = useDialog()
@@ -37,7 +36,6 @@ export function DialogSessionList() {
  const sessionTabs = useSessionTabs()
  const config = useConfig().data
  const toast = useToast()
-  const activeLocation = useLocation()
  const [filter, setFilter] = createSignal("")
  const shortcuts = Keymap.useShortcuts()
  const [search, setSearch] = createDebouncedSignal("", 150)
@@ -46,21 +44,13 @@ export function DialogSessionList() {
    initial: { allProjects: config.tabs?.scope !== "cwd" },
  })
  const allProjects = () => prefs.allProjects
-  const pickerLocation = () =>
-    (route.data.type === "session" ? data.session.get(route.data.sessionID)?.location : undefined) ??
-    activeLocation.ref ??
-    data.location.default()

  const [searchResults, { mutate: setSearchResults }] = createResource(
-    () => ({
-      query: search().trim(),
-      allProjects: allProjects(),
-      location: pickerLocation(),
-    }),
-    async ({ query, allProjects, location }) => {
+    () => ({ query: search().trim(), allProjects: allProjects() }),
+    async ({ query, allProjects }) => {
      try {
-        if (!data.location.info(location)) await data.location.sync(location)
-        const current = data.location.info(location)
+        if (!data.location.info()) await data.location.sync()
+        const current = data.location.info()
        if (!current) throw new Error("Location unavailable")
        const response = await client.api.session.list({
          ...(allProjects
@@ -88,7 +78,7 @@ export function DialogSessionList() {
  const currentSessionID = createMemo(() => (route.data.type === "session" ? route.data.sessionID : undefined))
  const localSessions = createMemo(() => {
    const query = filter().trim().toLowerCase()
-    const current = data.location.info(pickerLocation())
+    const current = data.location.info()
    const sessions = data.session
      .list()
      .filter(
@@ -135,7 +125,7 @@ export function DialogSessionList() {
    return hint && local.session.slots().length > 0 ? [{ title: "switch", label: hint }] : []
  })
  const currentProjectName = createMemo(() => {
-    const current = data.location.info(pickerLocation())
+    const current = data.location.info()
    if (!current) return ""
    const project = data.project.get(current.project.id)
    return projectName(project) ?? ""
@@ -1,127 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { expect, test } from "bun:test"
-import { testRender } from "@opentui/solid"
-import { onMount } from "solid-js"
-import { DialogSessionList } from "../../../src/component/dialog-session-list"
-import { ConfigProvider } from "../../../src/config"
-import { ArgsProvider } from "../../../src/context/args"
-import { ClientProvider } from "../../../src/context/client"
-import { DataProvider, useData } from "../../../src/context/data"
-import { Keymap } from "../../../src/context/keymap"
-import { LocalProvider } from "../../../src/context/local"
-import { LocationProvider } from "../../../src/context/location"
-import { PermissionProvider } from "../../../src/context/permission"
-import { RouteProvider, useRoute } from "../../../src/context/route"
-import { TuiAppProvider } from "../../../src/context/runtime"
-import { SessionTabsProvider } from "../../../src/context/session-tabs"
-import { StorageProvider, useStorage } from "../../../src/context/storage"
-import { ThemeProvider } from "../../../src/context/theme"
-import { DialogProvider, useDialog } from "../../../src/ui/dialog"
-import { ToastProvider } from "../../../src/ui/toast"
-import { createApi, createEventStream, createFetch, json } from "../../fixture/tui-client"
-import { emptyThemeSource, tmpdir } from "../../fixture/fixture"
-import { TestTuiContexts } from "../../fixture/tui-environment"
-import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
-
-test("scopes sessions to the active session location", async () => {
-  const active = "/tmp/opencode/project-b"
-  const events = createEventStream()
-  const requestedProjects: string[] = []
-  const calls = createFetch((url) => {
-    if (url.pathname === "/api/location") {
-      const directory = url.searchParams.get("location[directory]") ?? process.cwd()
-      const project = directory === active ? "proj_b" : "proj_a"
-      return json({ directory, project: { id: project, directory, canonical: directory } })
-    }
-    if (url.pathname !== "/api/session") return undefined
-    const project = url.searchParams.get("project") ?? ""
-    requestedProjects.push(project)
-    return json({
-      data: [
-        {
-          id: project === "proj_b" ? "ses_b" : "ses_a",
-          projectID: project,
-          cost: 0,
-          tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-          time: { created: 1, updated: 2 },
-          title: project === "proj_b" ? "Project B session" : "Project A session",
-          location: { directory: project === "proj_b" ? active : process.cwd() },
-        },
-      ],
-      cursor: {},
-    })
-  }, events)
-  const temporary = await tmpdir()
-  let storage!: ReturnType<typeof useStorage>
-
-  function Probe() {
-    const data = useData()
-    const dialog = useDialog()
-    const route = useRoute()
-    storage = useStorage()
-    onMount(() => {
-      data.session.remember({
-        id: "ses_active",
-        projectID: "proj_b",
-        cost: 0,
-        tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 1, updated: 3 },
-        title: "Active session",
-        location: { directory: active },
-      })
-      route.navigate({ type: "session", sessionID: "ses_active" })
-      dialog.replace(() => <DialogSessionList />)
-    })
-    return null
-  }
-
-  const app = await testRender(
-    () => (
-      <TestTuiContexts paths={{ state: temporary.path }}>
-        <TuiAppProvider value={{ name: "test", version: "test", channel: "test" }}>
-          <StorageProvider>
-            <ArgsProvider>
-              <ConfigProvider config={createTuiResolvedConfig()}>
-                <Keymap.Provider>
-                  <ToastProvider>
-                    <RouteProvider>
-                      <ClientProvider api={createApi(calls.fetch)}>
-                        <PermissionProvider>
-                          <DataProvider>
-                            <LocationProvider>
-                              <SessionTabsProvider>
-                                <ThemeProvider mode="dark" source={emptyThemeSource}>
-                                  <LocalProvider>
-                                    <DialogProvider>
-                                      <Probe />
-                                    </DialogProvider>
-                                  </LocalProvider>
-                                </ThemeProvider>
-                              </SessionTabsProvider>
-                            </LocationProvider>
-                          </DataProvider>
-                        </PermissionProvider>
-                      </ClientProvider>
-                    </RouteProvider>
-                  </ToastProvider>
-                </Keymap.Provider>
-              </ConfigProvider>
-            </ArgsProvider>
-          </StorageProvider>
-        </TuiAppProvider>
-      </TestTuiContexts>
-    ),
-    { width: 100, height: 30, kittyKeyboard: true },
-  )
-  app.renderer.start()
-
-  try {
-    const frame = await app.waitForFrame((value) => value.includes("Project B session"))
-    expect(frame).not.toContain("Project A session")
-    expect(requestedProjects.at(-1)).toBe("proj_b")
-  } finally {
-    app.renderer.destroy()
-    await storage.flush()
-    await temporary[Symbol.asyncDispose]()
-  }
-})
Author	SHA1	Message	Date
Shoubhit Dash	7084feb5e8	Merge remote-tracking branch 'origin/v2' into websocket-headers	2026-08-18 22:23:43 +05:30
Shoubhit Dash	b22187b1cf	chore: correct websocket changeset	2026-08-18 18:37:55 +05:30
Shoubhit Dash	f63a624578	fix(core): prefer websocket with request hooks	2026-08-18 18:28:08 +05:30