refactor(core): simplify prompt cache diagnostics

.changeset/bright-sols-write.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/ai": patch
----
-
-Report OpenAI prompt cache write tokens in normalized usage.

.changeset/quick-caches-roll.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/ai": patch
----
-
-Improve Anthropic and Bedrock prompt reuse with layered cache breakpoints that roll through long tool loops.

.github/workflows/deploy-www.yml

@@ -1,37 +0,0 @@
-name: deploy-www
-
-on:
-  push:
-    branches:
-      - dev
-      - v2
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-www-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && (github.ref_name == 'dev' || github.ref_name == 'v2')
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Build
-        working-directory: packages/www
-        run: bun run build
-        env:
-          BLUME_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
-          CLOUDFLARE_ENV: ${{ github.ref_name == 'v2' && 'production' || 'dev' }}
-
-      - name: Deploy
-        working-directory: packages/www
-        run: bun run deploy
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}

.github/workflows/test.yml

@@ -99,7 +99,7 @@ jobs:
 
       - name: Check generated documentation
         if: runner.os == 'Linux'
-        working-directory: packages/www
+        working-directory: packages/docs
         run: bun run check:generated
 
   e2e:

AGENTS.md

@@ -1,3 +1,4 @@
+- To regenerate the legacy JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
 - After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
 - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
 - Do not modify `packages/opencode` unless the user explicitly asks for V1 work. `packages/opencode` is the V1 implementation and is present for reference only. New implementation changes should land in the V2 package set: `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.

packages/ai/README.md

@@ -207,9 +207,7 @@ Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "aut
 
 ### Auto placement
 
-`"auto"` places up to four breakpoints — the last tool definition, the first system part, the last system part when distinct, and the final message boundary. These expose successively larger reusable prefixes for tools, the base agent, project instructions, and the active conversation. The rolling final-message boundary is the load-bearing detail in tool loops: it advances on every request so the previous cache entry stays within Anthropic's 20-block lookback.
-
-Tools precede every system and conversation block in the provider prefix, so tool definitions must remain byte-stable and deterministically ordered for downstream breakpoints to remain reusable.
+`"auto"` places three breakpoints — last tool definition, last system part, latest user message. The last-user-message boundary is the load-bearing detail: in a tool-use loop, a single user turn expands into many assistant/tool round-trips, all sharing that prefix. Caching at that boundary lets every intra-turn API call hit.
 
 The math justifies the default: Anthropic's 5-minute cache write is 1.25× base, read is 0.1×, so a single reuse within 5 minutes already wins. One-shot completions below the per-model minimum-cacheable-token threshold silently no-op on the wire, so the worst case is harmless.
 
@@ -237,7 +235,7 @@ cache: {
 
 ### Manual hints
 
-Inline `CacheHint` on any text / system / tool / tool-result part overrides automatic placement. The auto policy preserves manual hints, counts them against Anthropic and Bedrock's four-breakpoint limit, and only fills the remaining slots.
+Inline `CacheHint` on any text / system / tool / tool-result part overrides automatic placement. The auto policy preserves manual hints; it only fills gaps.
 
 ```ts
 LLM.request({
@@ -253,8 +251,8 @@ LLM.request({
 
 | Protocol                | `cache: "auto"`                                                           |
 | ----------------------- | ------------------------------------------------------------------------- |
-| Anthropic Messages      | emits up to 4 `cache_control` markers (4-breakpoint cap enforced)         |
-| Bedrock Converse        | emits up to 4 `cachePoint` blocks (4-breakpoint cap enforced)             |
+| Anthropic Messages      | emits up to 3 `cache_control` markers (4-breakpoint cap enforced)         |
+| Bedrock Converse        | emits up to 3 `cachePoint` blocks (4-breakpoint cap enforced)             |
 | OpenAI Chat / Responses | no-op (implicit caching above 1024 tokens)                                |
 | Gemini                  | no-op (implicit caching on 2.5+; explicit `CachedContent` is out-of-band) |
 

packages/ai/src/cache-policy.ts

@@ -2,31 +2,32 @@
 // the policy designates. Runs once at compile time, before the per-protocol
 // body builder, so the existing inline-hint lowering path handles the rest.
 //
-// The default `"auto"` shape places breakpoints at the last tool definition,
-// the first and last distinct system parts, and the conversation tail. This
-// exposes reusable tool, base-agent, project, and session prefixes while
-// advancing the tail after each tool result keeps the previous cache entry
-// within Anthropic's 20-block lookback during long agent turns.
+// The default `"auto"` shape places one breakpoint at the last tool definition,
+// one at the last system part, and one at the latest user message. This
+// matches what production agent harnesses (LangChain's caching middleware,
+// kern-ai's 10x cost-reduction playbook) converge on for tool-use loops: the
+// latest user message stays put while a single turn explodes into many
+// assistant/tool round-trips, so caching at that boundary lets every
+// intra-turn API call hit the prefix.
 //
-// Manual `cache: CacheHint` placements on individual parts are preserved and
-// count against the four-breakpoint budget; auto only fills remaining slots.
+// Manual `cache: CacheHint` placements on individual parts are preserved —
+// this function only fills gaps the caller left empty.
 import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options"
 import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages"
 
 const AUTO: CachePolicyObject = {
   tools: true,
   system: true,
-  messages: { tail: 1 },
+  messages: "latest-user-message",
 }
 
 const NONE: CachePolicyObject = {}
-const BREAKPOINT_CAP = 4
 
 // Resolution rules:
 //   - undefined   → "auto" — caching is on by default. The math favors it:
 //                   Anthropic 5m-cache write is 1.25x base, read is 0.1x,
 //                   so a single reuse within 5 minutes already wins.
-//   - "auto"      → tools + first/last system + final message boundary.
+//   - "auto"      → tools + system + latest user msg.
 //   - "none"      → no auto placement; manual `CacheHint`s still flow.
 //   - object form → exactly what the caller asked for.
 const resolve = (policy: CachePolicy | undefined): CachePolicyObject => {
@@ -43,32 +44,18 @@ const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "bedrock-converse"]
 const makeHint = (ttlSeconds: number | undefined): CacheHint =>
   ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" })
 
-interface Budget {
-  remaining: number
-}
-
-const markLastTool = (
-  tools: ReadonlyArray<ToolDefinition>,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<ToolDefinition> => {
+const markLastTool = (tools: ReadonlyArray<ToolDefinition>, hint: CacheHint): ReadonlyArray<ToolDefinition> => {
   if (tools.length === 0) return tools
   const last = tools.length - 1
-  if (tools[last]!.cache || budget.remaining === 0) return tools
-  budget.remaining -= 1
+  if (tools[last]!.cache) return tools
   return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
 }
 
-const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
+const markLastSystem = (system: LLMRequest["system"], hint: CacheHint): LLMRequest["system"] => {
   if (system.length === 0) return system
-  let changed = false
-  const next = system.map((part, index) => {
-    if ((index !== 0 && index !== system.length - 1) || part.cache || budget.remaining === 0) return part
-    budget.remaining -= 1
-    changed = true
-    return { ...part, cache: hint }
-  })
-  return changed ? next : system
+  const last = system.length - 1
+  if (system[last]!.cache) return system
+  return system.map((part, i) => (i === last ? { ...part, cache: hint } : part))
 }
 
 const lastIndexOfRole = (messages: ReadonlyArray<Message>, role: Message["role"]): number =>
@@ -77,20 +64,14 @@ const lastIndexOfRole = (messages: ReadonlyArray<Message>, role: Message["role"]
 // Mark the last text part of `messages[index]`. If no text part exists, mark
 // the last content part regardless of type — that's the breakpoint position
 // in tool-result-only messages too.
-const markMessageAt = (
-  messages: ReadonlyArray<Message>,
-  index: number,
-  hint: CacheHint,
-  budget: Budget,
-): ReadonlyArray<Message> => {
+const markMessageAt = (messages: ReadonlyArray<Message>, index: number, hint: CacheHint): ReadonlyArray<Message> => {
   if (index < 0 || index >= messages.length) return messages
   const target = messages[index]!
   if (target.content.length === 0) return messages
   const lastTextIndex = target.content.findLastIndex((part) => part.type === "text")
   const markAt = lastTextIndex >= 0 ? lastTextIndex : target.content.length - 1
   const existing = target.content[markAt]!
-  if (("cache" in existing && existing.cache) || budget.remaining === 0) return messages
-  budget.remaining -= 1
+  if ("cache" in existing && existing.cache) return messages
   const nextContent = target.content.map((part, i) => (i === markAt ? ({ ...part, cache: hint } as ContentPart) : part))
   const next = new Message({ ...target, content: nextContent })
   // Single pass over `messages`, substituting the one updated entry. Long
@@ -105,42 +86,25 @@ const markMessages = (
   messages: ReadonlyArray<Message>,
   strategy: NonNullable<CachePolicyObject["messages"]>,
   hint: CacheHint,
-  budget: Budget,
 ): ReadonlyArray<Message> => {
   if (messages.length === 0) return messages
-  if (strategy === "latest-user-message")
-    return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint, budget)
-  if (strategy === "latest-assistant")
-    return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint, budget)
+  if (strategy === "latest-user-message") return markMessageAt(messages, lastIndexOfRole(messages, "user"), hint)
+  if (strategy === "latest-assistant") return markMessageAt(messages, lastIndexOfRole(messages, "assistant"), hint)
   const start = Math.max(0, messages.length - strategy.tail)
   let next = messages
-  for (let i = start; i < messages.length; i++) next = markMessageAt(next, i, hint, budget)
+  for (let i = start; i < messages.length; i++) next = markMessageAt(next, i, hint)
   return next
 }
 
-const countHints = (request: LLMRequest) =>
-  request.tools.reduce((count, tool) => count + (tool.cache === undefined ? 0 : 1), 0) +
-  request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
-  request.messages.reduce(
-    (count, message) =>
-      count +
-      message.content.reduce(
-        (contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0),
-        0,
-      ),
-    0,
-  )
-
 export const applyCachePolicy = (request: LLMRequest): LLMRequest => {
   if (!RESPECTS_INLINE_HINTS.has(request.model.route.id)) return request
   const policy = resolve(request.cache)
   if (!policy.tools && !policy.system && !policy.messages) return request
 
   const hint = makeHint(policy.ttlSeconds)
-  const budget = { remaining: Math.max(0, BREAKPOINT_CAP - countHints(request)) }
-  const tools = policy.tools ? markLastTool(request.tools, hint, budget) : request.tools
-  const system = policy.system ? markSystemBoundaries(request.system, hint, budget) : request.system
-  const messages = policy.messages ? markMessages(request.messages, policy.messages, hint, budget) : request.messages
+  const tools = policy.tools ? markLastTool(request.tools, hint) : request.tools
+  const system = policy.system ? markLastSystem(request.system, hint) : request.system
+  const messages = policy.messages ? markMessages(request.messages, policy.messages, hint) : request.messages
 
   if (tools === request.tools && system === request.system && messages === request.messages) return request
   return LLMRequest.update(request, { tools, system, messages })

packages/ai/src/protocols/anthropic-messages.ts

@@ -7,10 +7,8 @@ import { Protocol } from "../route/protocol"
 import {
   LLMError,
   LLMEvent,
-  mergeJsonRecords,
   Usage,
   type CacheHint,
-  type FinishReasonDetails,
   type FinishReason,
   type JsonSchema,
   type LLMRequest,
@@ -235,27 +233,12 @@ const AnthropicBodyFields = {
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
-const AnthropicUsage = Schema.StructWithRest(
-  Schema.Struct({
-    input_tokens: Schema.optional(Schema.Number),
-    output_tokens: Schema.optional(Schema.Number),
-    cache_creation_input_tokens: optionalNull(Schema.Number),
-    cache_read_input_tokens: optionalNull(Schema.Number),
-    server_tool_use: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({ web_search_requests: Schema.optional(Schema.Number) }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-    output_tokens_details: optionalNull(
-      Schema.StructWithRest(
-        Schema.Struct({ thinking_tokens: Schema.optional(Schema.Number) }),
-        [Schema.Record(Schema.String, Schema.Unknown)],
-      ),
-    ),
-  }),
-  [Schema.Record(Schema.String, Schema.Unknown)],
-)
+const AnthropicUsage = Schema.Struct({
+  input_tokens: Schema.optional(Schema.Number),
+  output_tokens: Schema.optional(Schema.Number),
+  cache_creation_input_tokens: optionalNull(Schema.Number),
+  cache_read_input_tokens: optionalNull(Schema.Number),
+})
 type AnthropicUsage = Schema.Schema.Type<typeof AnthropicUsage>
 
 const AnthropicStreamBlock = Schema.Struct({
@@ -305,12 +288,7 @@ type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 
 interface ParserState {
   readonly tools: ToolStream.State<number>
-  readonly reasoningSignatures: Readonly<Record<number, string>>
   readonly usage?: Usage
-  readonly pendingFinish?: {
-    readonly reason: FinishReasonDetails
-    readonly providerMetadata?: ProviderMetadata
-  }
   readonly lifecycle: Lifecycle.State
 }
 
@@ -682,8 +660,9 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // `input_tokens` is the *non-cached* count per the Messages API docs, with
 // cache reads and writes as separate fields. We sum them to derive the
 // inclusive `inputTokens` the rest of the contract expects. Extended
-// thinking tokens are included in `output_tokens`; newer responses also
-// expose that subset through `output_tokens_details.thinking_tokens`.
+// thinking tokens are *not* broken out by Anthropic — they're billed as
+// part of `output_tokens`, so `reasoningTokens` stays `undefined` and
+// `outputTokens` carries the combined total.
 const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
   if (!usage) return undefined
   const nonCached = usage.input_tokens
@@ -696,7 +675,6 @@ const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cacheRead,
     cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
     providerMetadata: { anthropic: usage },
   })
@@ -715,18 +693,18 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined) => {
   const cacheWriteInputTokens = right.cacheWriteInputTokens ?? left.cacheWriteInputTokens
   const inputTokens = ProviderShared.sumTokens(nonCachedInputTokens, cacheReadInputTokens, cacheWriteInputTokens)
   const outputTokens = right.outputTokens ?? left.outputTokens
-  const reasoningTokens = right.reasoningTokens ?? left.reasoningTokens
   return new Usage({
     inputTokens,
     outputTokens,
     nonCachedInputTokens,
     cacheReadInputTokens,
     cacheWriteInputTokens,
-    reasoningTokens,
     totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
     providerMetadata: {
-      anthropic:
-        mergeJsonRecords(left.providerMetadata?.["anthropic"], right.providerMetadata?.["anthropic"]) ?? {},
+      anthropic: {
+        ...left.providerMetadata?.["anthropic"],
+        ...right.providerMetadata?.["anthropic"],
+      },
     },
   })
 }
@@ -785,10 +763,6 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
         tools: ToolStream.start(state.tools, event.index, {
           id: block.id ?? String(event.index),
           name: block.name ?? "",
-          input:
-            block.input !== undefined && (!ProviderShared.isRecord(block.input) || Object.keys(block.input).length > 0)
-              ? ProviderShared.encodeJson(block.input)
-              : undefined,
           providerExecuted: block.type === "server_tool_use",
         }),
       },
@@ -803,31 +777,20 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
     ]
   }
 
-  if (block.type === "text" && block.text !== undefined) {
+  if (block.type === "text" && block.text) {
     const events: LLMEvent[] = []
-    const id = `text-${event.index ?? 0}`
-    const lifecycle = Lifecycle.textStart(state.lifecycle, events, id)
     return [
-      { ...state, lifecycle: block.text ? Lifecycle.textDelta(lifecycle, events, id, block.text) : lifecycle },
+      { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, `text-${event.index ?? 0}`, block.text) },
       events,
     ]
   }
 
-  if (block.type === "thinking" && block.thinking !== undefined) {
+  if (block.type === "thinking" && block.thinking) {
     const events: LLMEvent[] = []
-    const id = `reasoning-${event.index ?? 0}`
-    const providerMetadata = block.signature === undefined ? undefined : anthropicMetadata({ signature: block.signature })
-    const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, providerMetadata)
     return [
       {
         ...state,
-        lifecycle: block.thinking
-          ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, providerMetadata)
-          : lifecycle,
-        reasoningSignatures:
-          event.index === undefined || block.signature === undefined
-            ? state.reasoningSignatures
-            : { ...state.reasoningSignatures, [event.index]: block.signature },
+        lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${event.index ?? 0}`, block.thinking),
       },
       events,
     ]
@@ -836,7 +799,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
   // Redacted thinking surfaces as an empty reasoning part carrying the opaque
   // payload as `redactedData` metadata (same model as Vercel's
   // @ai-sdk/anthropic). The existing content_block_stop closes the part.
-  if (block.type === "redacted_thinking" && block.data !== undefined) {
+  if (block.type === "redacted_thinking" && block.data) {
     const events: LLMEvent[] = []
     return [
       {
@@ -884,13 +847,18 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
   }
 
   if (delta?.type === "signature_delta" && delta.signature) {
-    const index = event.index ?? 0
+    const events: LLMEvent[] = []
     return [
       {
         ...state,
-        reasoningSignatures: { ...state.reasoningSignatures, [index]: delta.signature },
+        lifecycle: Lifecycle.reasoningEnd(
+          state.lifecycle,
+          events,
+          `reasoning-${event.index ?? 0}`,
+          anthropicMetadata({ signature: delta.signature }),
+        ),
       },
-      NO_EVENTS,
+      events,
     ] satisfies StepResult
   }
 
@@ -921,53 +889,31 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
   const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index)
   const events: LLMEvent[] = []
   const resultEvents = result.events ?? []
-  const signature = state.reasoningSignatures[event.index]
   const lifecycle = resultEvents.length
     ? Lifecycle.stepStart(state.lifecycle, events)
     : Lifecycle.reasoningEnd(
         Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`),
         events,
         `reasoning-${event.index}`,
-        signature === undefined ? undefined : anthropicMetadata({ signature }),
       )
   events.push(...resultEvents)
-  const reasoningSignatures = { ...state.reasoningSignatures }
-  delete reasoningSignatures[event.index]
-  return [{ ...state, lifecycle, tools: result.tools, reasoningSignatures }, events] satisfies StepResult
+  return [{ ...state, lifecycle, tools: result.tools }, events] satisfies StepResult
 })
 
 const onMessageDelta = (state: ParserState, event: AnthropicEvent): StepResult => {
   const usage = mergeUsage(state.usage, mapUsage(event.usage))
-  return [
-    {
-      ...state,
-      usage,
-      pendingFinish: {
-        reason: {
-          normalized: mapFinishReason(event.delta?.stop_reason),
-          raw: event.delta?.stop_reason ?? undefined,
-        },
-        providerMetadata:
-          event.delta?.stop_sequence === null || event.delta?.stop_sequence === undefined
-            ? undefined
-            : anthropicMetadata({ stopSequence: event.delta.stop_sequence }),
-      },
-    },
-    NO_EVENTS,
-  ]
-}
-
-const onMessageStop = (state: ParserState): StepResult => {
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-    reason: state.pendingFinish?.reason ?? {
-      normalized: "unknown",
-      raw: undefined,
+    reason: {
+      normalized: mapFinishReason(event.delta?.stop_reason),
+      raw: event.delta?.stop_reason ?? undefined,
     },
-    usage: state.usage,
-    providerMetadata: state.pendingFinish?.providerMetadata,
+    usage,
+    providerMetadata: event.delta?.stop_sequence
+      ? anthropicMetadata({ stopSequence: event.delta.stop_sequence })
+      : undefined,
   })
-  return [{ ...state, lifecycle }, events]
+  return [{ ...state, lifecycle, usage }, events]
 }
 
 // Prefix `error.type` so overloads, rate limits, and quota errors are visible
@@ -992,7 +938,6 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   if (event.type === "content_block_delta") return onContentBlockDelta(state, event)
   if (event.type === "content_block_stop") return onContentBlockStop(state, event)
   if (event.type === "message_delta") return Effect.succeed(onMessageDelta(state, event))
-  if (event.type === "message_stop") return Effect.succeed(onMessageStop(state))
   if (event.type === "error") return onError(event)
   return Effect.succeed<StepResult>([state, NO_EVENTS])
 }
@@ -1013,11 +958,7 @@ export const protocol = Protocol.make({
   },
   stream: {
     event: Protocol.jsonEvent(AnthropicEvent),
-    initial: () => ({
-      tools: ToolStream.empty<number>(),
-      reasoningSignatures: {},
-      lifecycle: Lifecycle.initial(),
-    }),
+    initial: () => ({ tools: ToolStream.empty<number>(), lifecycle: Lifecycle.initial() }),
     step,
   },
 })

packages/ai/src/protocols/open-responses.ts

@@ -55,9 +55,6 @@ const OpenResponsesOutputText = Schema.Struct({
   text: Schema.String,
 })
 
-export const MessagePhase = Schema.Literals(["commentary", "final_answer"])
-type MessagePhase = Schema.Schema.Type<typeof MessagePhase>
-
 const OpenResponsesReasoningSummaryText = Schema.Struct({
   type: Schema.tag("summary_text"),
   text: Schema.String,
@@ -89,14 +86,10 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
   Schema.Array(OpenResponsesFunctionCallOutputContent),
 ])
 
-export const InputItem = Schema.Union([
+const OpenResponsesInputItem = Schema.Union([
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
-  Schema.Struct({
-    role: Schema.tag("assistant"),
-    content: Schema.Array(OpenResponsesOutputText),
-    phase: Schema.optionalKey(MessagePhase),
-  }),
+  Schema.Struct({ role: Schema.tag("assistant"), content: Schema.Array(OpenResponsesOutputText) }),
   OpenResponsesReasoningItem,
   OpenResponsesItemReference,
   Schema.Struct({
@@ -111,14 +104,7 @@ export const InputItem = Schema.Union([
     output: OpenResponsesFunctionCallOutput,
   }),
 ])
-type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
-type LoweredInputItem =
-  | OpenResponsesInputItem
-  | {
-      readonly role: "assistant"
-      readonly content: ReadonlyArray<{ readonly type: "output_text"; readonly text: string }>
-      readonly phase?: MessagePhase | null
-    }
+type OpenResponsesInputItem = Schema.Schema.Type<typeof OpenResponsesInputItem>
 
 // Mutable counterpart of the schema reasoning item so `lowerMessages` can fold
 // multiple streamed summary parts into the same item before flushing.
@@ -149,7 +135,7 @@ export const ToolChoice = Schema.Union([
 // transports in sync without a destructure-and-strip dance.
 export const coreFields = {
   model: Schema.String,
-  input: Schema.Array(InputItem),
+  input: Schema.Array(OpenResponsesInputItem),
   instructions: Schema.optional(Schema.String),
   tools: optionalArray(Tool),
   tool_choice: Schema.optional(ToolChoice),
@@ -181,12 +167,7 @@ export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>
 
 const OpenResponsesUsage = Schema.Struct({
   input_tokens: Schema.optional(Schema.Number),
-  input_tokens_details: optionalNull(
-    Schema.Struct({
-      cached_tokens: Schema.optional(Schema.Number),
-      cache_write_tokens: Schema.optional(Schema.Number),
-    }),
-  ),
+  input_tokens_details: optionalNull(Schema.Struct({ cached_tokens: Schema.optional(Schema.Number) })),
   output_tokens: Schema.optional(Schema.Number),
   output_tokens_details: optionalNull(Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) })),
   total_tokens: Schema.optional(Schema.Number),
@@ -220,7 +201,6 @@ export const Event = Schema.StructWithRest(
   Schema.Struct({
     type: Schema.String,
     delta: Schema.optional(Schema.String),
-    text: Schema.optional(Schema.String),
     item_id: Schema.optional(Schema.String),
     summary_index: Schema.optional(Schema.Number),
     item: Schema.optional(StreamItem),
@@ -253,7 +233,6 @@ export interface Extension {
     readonly media: ProviderShared.ValidatedMedia
     readonly request: LLMRequest
   }) => MediaInput | undefined
-  readonly messagePhase?: (value: unknown) => MessagePhase | null | undefined
 }
 
 const BASE: Extension = { id: ADAPTER, name: NAME }
@@ -265,9 +244,6 @@ export interface ParserState {
   readonly tools: ToolStream.State<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
-  readonly messageItems: ReadonlySet<string>
-  readonly messagePhase: (value: unknown) => MessagePhase | null | undefined
-  readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
   readonly store: boolean | undefined
 }
@@ -397,9 +373,9 @@ const lowerToolResultOutput = Effect.fn("OpenResponses.lowerToolResultOutput")(f
 })
 
 const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (request: LLMRequest, extension: Extension) {
-  const system: LoweredInputItem[] =
+  const system: OpenResponsesInputItem[] =
     request.system.length === 0 ? [] : [{ role: "system", content: ProviderShared.joinText(request.system) }]
-  const input: LoweredInputItem[] = [...system]
+  const input: OpenResponsesInputItem[] = [...system]
   const store = OpenResponsesOptions.resolve(request).store
   const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
@@ -431,27 +407,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
       const hostedToolReferences = new Set<string>()
       const flushText = () => {
         if (content.length === 0) return
-        const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
-          (groups, part) => {
-            const metadata = part.providerMetadata?.[providerMetadataKey]
-            const phase =
-              ProviderShared.isRecord(metadata)
-                ? messagePhase(metadata.phase, extension)
-                : undefined
-            const group = groups.at(-1)
-            if (group && group.phase === phase) group.parts.push(part)
-            else groups.push({ phase, parts: [part] })
-            return groups
-          },
-          [],
-        )
-        input.push(
-          ...groups.map((group) => ({
-            role: "assistant" as const,
-            content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
-            ...(group.phase === undefined ? {} : { phase: group.phase }),
-          })),
-        )
+        input.push({ role: "assistant", content: content.map((part) => ({ type: "output_text", text: part.text })) })
         content.splice(0, content.length)
       }
       for (const part of message.content) {
@@ -552,9 +508,9 @@ const lowerOptions = (request: LLMRequest) => {
   }
 }
 
-export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWithExtension")(function* (
+export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (
   request: LLMRequest,
-  extension: Extension,
+  extension: Extension = BASE,
 ) {
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -580,31 +536,23 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
   }
 })
 
-const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesBody))
-
-export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (request: LLMRequest) {
-  return yield* decodeBody(yield* fromRequestWithExtension(request, BASE))
-})
-
 // =============================================================================
 // Stream Parsing
 // =============================================================================
 // Responses APIs report `input_tokens` (inclusive total) with a
-// cached-read and cache-write subsets, and `output_tokens` (inclusive total)
-// with a `reasoning_tokens` subset. Pass the totals through and derive the
+// `cached_tokens` subset, and `output_tokens` (inclusive total) with a
+// `reasoning_tokens` subset. Pass the totals through and derive the
 // non-cached breakdown.
 const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
   if (!usage) return undefined
   const cached = usage.input_tokens_details?.cached_tokens
-  const cacheWrite = usage.input_tokens_details?.cache_write_tokens
   const reasoning = usage.output_tokens_details?.reasoning_tokens
-  const nonCached = ProviderShared.subtractTokens(usage.input_tokens, ProviderShared.sumTokens(cached, cacheWrite))
+  const nonCached = ProviderShared.subtractTokens(usage.input_tokens, cached)
   return new Usage({
     inputTokens: usage.input_tokens,
     outputTokens: usage.output_tokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cached,
-    cacheWriteInputTokens: cacheWrite,
     reasoningTokens: reasoning,
     totalTokens: ProviderShared.totalTokens(usage.input_tokens, usage.output_tokens, usage.total_tokens),
     providerMetadata: { [providerMetadataKey]: usage },
@@ -640,30 +588,24 @@ const NO_EVENTS: StepResult["1"] = []
 const TERMINAL_TYPES = new Set(["response.completed", "response.incomplete", "response.failed"])
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
-const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
+const onOutputTextDelta = (state: ParserState, event: Event): StepResult => {
   if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
-  const phase = state.messagePhases[id]
-  const metadata = phase === undefined ? undefined : providerMetadata(state, { phase })
-  const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [
-    { ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) },
+    { ...state, lifecycle: Lifecycle.textDelta(state.lifecycle, events, event.item_id ?? "text-0", event.delta) },
     events,
   ]
 }
 
-const onOutputTextDone = (state: ParserState, event: Event, id: string): StepResult => {
-  if (state.messageItems.has(id)) {
-    if (state.lifecycle.text.has(id) || event.text === undefined) return [state, NO_EVENTS]
-    return onOutputTextDelta(state, { ...event, delta: event.text }, id)
-  }
+const onOutputTextDone = (state: ParserState, event: Event): StepResult => {
   const events: LLMEvent[] = []
-  return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, id) }, events]
+  return [{ ...state, lifecycle: Lifecycle.textEnd(state.lifecycle, events, event.item_id ?? "text-0") }, events]
 }
 
-export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
+export const onReasoningDelta = (state: ParserState, event: Event): StepResult => {
   if (!event.delta) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
+  const itemID = event.item_id ?? "reasoning-0"
   const id =
     event.summary_index !== undefined || state.reasoningItems[itemID] ? `${itemID}:${event.summary_index ?? 0}` : itemID
   return [
@@ -694,18 +636,6 @@ const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
-  if (item?.type === "message" && item.id)
-    return [
-      {
-        ...state,
-        messageItems: new Set([...state.messageItems, item.id]),
-        messagePhases: (() => {
-          const phase = state.messagePhase(item.phase)
-          return phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase }
-        })(),
-      },
-      NO_EVENTS,
-    ]
   if (item && isReasoningItem(item)) {
     const events: LLMEvent[] = []
     return [
@@ -862,28 +792,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   const item = event.item
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
-  if (item.type === "message" && item.id) {
-    const itemPhase = state.messagePhase(item.phase)
-    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
-    const events: LLMEvent[] = []
-    const messageItems = new Set(state.messageItems)
-    messageItems.delete(item.id)
-    const { [item.id]: _phase, ...messagePhases } = state.messagePhases
-    return [
-      {
-        ...state,
-        lifecycle: Lifecycle.textEnd(
-          state.lifecycle,
-          events,
-          item.id,
-          phase === undefined ? undefined : providerMetadata(state, { phase }),
-        ),
-        messageItems,
-        messagePhases,
-      },
-      events,
-    ] satisfies StepResult
-  }
+  if (item.type === "message" && item.id) return onOutputTextDone(state, { ...event, item_id: item.id })
 
   if (item.type === "function_call") {
     if (!item.id || !item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
@@ -983,41 +892,19 @@ const providerError = (state: ParserState, event: Event, fallback: string) => {
 }
 
 export const step = (state: ParserState, event: Event) => {
-  if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-    return Effect.succeed(
-      event.type === "response.output_text.delta"
-        ? onOutputTextDelta(state, event, event.item_id)
-        : onOutputTextDone(state, event, event.item_id),
-    )
-  }
-  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-    return Effect.succeed(onReasoningDelta(state, event, event.item_id))
-  }
-  if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done") {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+  if (event.type === "response.output_text.delta") return Effect.succeed(onOutputTextDelta(state, event))
+  if (event.type === "response.output_text.done") return Effect.succeed(onOutputTextDone(state, event))
+  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta")
+    return Effect.succeed(onReasoningDelta(state, event))
+  if (event.type === "response.reasoning.done" || event.type === "response.reasoning_summary_text.done")
     return Effect.succeed(onReasoningDone(state, event))
-  }
   if (event.type === "response.reasoning_summary_part.added")
-    return event.item_id
-      ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
-      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    return Effect.succeed(onReasoningSummaryPartAdded(state, event))
   if (event.type === "response.reasoning_summary_part.done")
-    return event.item_id
-      ? Effect.succeed(onReasoningSummaryPartDone(state, event))
-      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.added") {
-    if (event.item?.type === "message" && !event.item.id)
-      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
-    return Effect.succeed(onOutputItemAdded(state, event))
-  }
+    return Effect.succeed(onReasoningSummaryPartDone(state, event))
+  if (event.type === "response.output_item.added") return Effect.succeed(onOutputItemAdded(state, event))
   if (event.type === "response.function_call_arguments.delta") return onFunctionCallArgumentsDelta(state, event)
-  if (event.type === "response.output_item.done") {
-    if (event.item?.type === "message" && !event.item.id)
-      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
-    return onOutputItemDone(state, event)
-  }
+  if (event.type === "response.output_item.done") return onOutputItemDone(state, event)
   if (event.type === "response.completed" || event.type === "response.incomplete")
     return Effect.succeed(onResponseFinish(state, event))
   if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
@@ -1039,18 +926,10 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
   lifecycle: Lifecycle.initial(),
-  messageItems: new Set<string>(),
-  messagePhase: (value) => messagePhase(value, extension),
-  messagePhases: {},
   reasoningItems: {},
   store: OpenResponsesOptions.resolve(request).store,
 })
 
-const messagePhase = (value: unknown, extension: Extension): MessagePhase | null | undefined => {
-  if (value === "commentary" || value === "final_answer") return value
-  return extension.messagePhase?.(value)
-}
-
 export const protocol = Protocol.make({
   id: ADAPTER,
   body: {

packages/ai/src/protocols/openai-chat.ts

@@ -131,7 +131,6 @@ const OpenAIChatUsage = Schema.Struct({
   prompt_tokens_details: optionalNull(
     Schema.Struct({
       cached_tokens: Schema.optional(Schema.Number),
-      cache_write_tokens: Schema.optional(Schema.Number),
     }),
   ),
   completion_tokens_details: optionalNull(
@@ -454,22 +453,20 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 }
 
 // OpenAI Chat reports `prompt_tokens` (inclusive total) with a
-// cached-read and cache-write subsets, and `completion_tokens` (inclusive
-// total) with a `reasoning_tokens` subset. We pass the inclusive totals
-// through and derive the non-cached breakdown so the `LLM.Usage` contract is
+// `cached_tokens` subset, and `completion_tokens` (inclusive total) with
+// a `reasoning_tokens` subset. We pass the inclusive totals through and
+// derive the non-cached breakdown so the `LLM.Usage` contract is
 // satisfied on both sides.
 const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
   if (!usage) return undefined
   const cached = usage.prompt_tokens_details?.cached_tokens
-  const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens
   const reasoning = usage.completion_tokens_details?.reasoning_tokens
-  const nonCached = ProviderShared.subtractTokens(usage.prompt_tokens, ProviderShared.sumTokens(cached, cacheWrite))
+  const nonCached = ProviderShared.subtractTokens(usage.prompt_tokens, cached)
   return new Usage({
     inputTokens: usage.prompt_tokens,
     outputTokens: usage.completion_tokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cached,
-    cacheWriteInputTokens: cacheWrite,
     reasoningTokens: reasoning,
     totalTokens: ProviderShared.totalTokens(usage.prompt_tokens, usage.completion_tokens, usage.total_tokens),
     providerMetadata: { openai: usage },

packages/ai/src/protocols/openai-responses.ts

@@ -35,18 +35,8 @@ const OpenAIResponsesToolChoice = Schema.Union([
   Schema.Struct({ type: Schema.tag("image_generation") }),
 ])
 
-const OpenAIResponsesInputItem = Schema.Union([
-  Schema.Struct({
-    role: Schema.tag("assistant"),
-    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
-    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
-  }),
-  OpenResponses.InputItem,
-])
-
 const OpenAIResponsesCoreFields = {
   ...OpenResponses.coreFields,
-  input: Schema.Array(OpenAIResponsesInputItem),
   tools: optionalArray(OpenAIResponsesTools),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
 }
@@ -70,7 +60,6 @@ const encodeWebSocketMessage = Schema.encodeSync(Schema.fromJsonString(OpenAIRes
 const extension = {
   id: ADAPTER,
   name: NAME,
-  messagePhase: (value: unknown) => (value === null ? null : undefined),
   lowerMedia: ({ part, media, request }) => {
     if (request.model.provider !== "xai" || media.mime !== "application/pdf") return undefined
     return {
@@ -113,7 +102,7 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tool
   })
 
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const body = yield* OpenResponses.fromRequestWithExtension(
+  const body = yield* OpenResponses.fromRequest(
     LLMRequest.update(request, { tools: [], toolChoice: undefined }),
     extension,
   )
@@ -219,13 +208,9 @@ const onHostedToolDone = Effect.fn("OpenAIResponses.onHostedToolDone")(function*
 
 const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.reasoning_text.delta" || event.type === "response.reasoning_summary.delta")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
+    return Effect.succeed(OpenResponses.onReasoningDelta(state, event))
   if (event.type === "response.reasoning_text.done" || event.type === "response.reasoning_summary.done")
-    return event.item_id
-      ? Effect.succeed(OpenResponses.onReasoningDone(state, event))
-      : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
+    return Effect.succeed(OpenResponses.onReasoningDone(state, event))
   if (event.type === "response.output_item.done" && event.item && isHostedToolItem(event.item))
     return onHostedToolDone(state, event.item)
   return OpenResponses.step(state, event)

packages/ai/src/protocols/utils/lifecycle.ts

@@ -14,17 +14,14 @@ export const stepStart = (state: State, events: LLMEvent[]): State => {
   return { ...state, stepStarted: true }
 }
 
-export const textStart = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
-  if (state.text.has(id)) return state
-  const stepped = stepStart(state, events)
-  events.push(LLMEvent.textStart({ id, providerMetadata }))
-  return { ...stepped, text: new Set([...stepped.text, id]) }
-}
-
 export const textDelta = (state: State, events: LLMEvent[], id: string, text: string): State => {
-  const started = textStart(state, events, id)
-  events.push(LLMEvent.textDelta({ id, text }))
-  return started
+  const stepped = stepStart(state, events)
+  if (stepped.text.has(id)) {
+    events.push(LLMEvent.textDelta({ id, text }))
+    return stepped
+  }
+  events.push(LLMEvent.textStart({ id }), LLMEvent.textDelta({ id, text }))
+  return { ...stepped, text: new Set([...stepped.text, id]) }
 }
 
 export const reasoningStart = (

packages/ai/src/schema/events.ts

@@ -40,9 +40,9 @@ import { ProviderFailureClassification } from "./errors"
  * - Anthropic and Bedrock report the input breakdown natively: Anthropic's
  *   `input_tokens` and Bedrock's `inputTokens` are non-cached only. Their
  *   mappers sum the breakdown to derive the inclusive `inputTokens`.
- *   Anthropic's `outputTokens` includes extended thinking. Newer responses
- *   expose that subset as `output_tokens_details.thinking_tokens`, which maps
- *   to `reasoningTokens`; older responses leave it undefined.
+ *   Anthropic does *not* break extended-thinking out of `output_tokens`, so
+ *   `reasoningTokens` is `undefined` and `outputTokens` carries the
+ *   combined total — a documented limitation of the Anthropic API.
  *
  * `providerMetadata` always carries the provider's raw usage payload —
  * keyed by provider name (`{ openai: ... }`, `{ anthropic: ... }`, etc.)

packages/ai/src/schema/options.ts

@@ -251,11 +251,11 @@ export class CacheHint extends Schema.Class<CacheHint>("LLM.CacheHint")({
 // Auto-placement policy for prompt caching. The protocol-neutral lowering step
 // reads this and injects `CacheHint`s at the configured boundaries; the
 // per-protocol body builders then translate those hints into wire markers as
-// usual. `"auto"` is the recommended default for agent loops — it places
-// breakpoints at the last tool definition, the first and last distinct system
-// parts, and the conversation tail. The rolling message breakpoint keeps a
-// prior cache entry within Anthropic/Bedrock's 20-block lookback during long
-// tool loops.
+// usual. `"auto"` is the recommended default for agent loops — it places one
+// breakpoint at the last tool definition, one at the last system part, and one
+// at the latest user message. The combination of provider invalidation
+// hierarchy (tools → system → messages) and Anthropic/Bedrock's 20-block
+// lookback means three trailing breakpoints reliably cover the static prefix.
 //
 // Pass `"none"` to opt out entirely (the legacy behavior). Pass the granular
 // object form to override individual choices.

packages/ai/test/cache-policy.test.ts

@@ -39,8 +39,8 @@ describe("applyCachePolicy", () => {
         }),
       )
 
-      // A single system block is both the first and last boundary, so the auto
-      // policy deduplicates it and still marks the conversation tail.
+      // No explicit cache field → auto policy fires → last system part + latest
+      // user message both get cache_control markers.
       expect(prepared.body).toMatchObject({
         system: [{ type: "text", text: "You are concise.", cache_control: { type: "ephemeral" } }],
         messages: [{ role: "user", content: [{ type: "text", text: "hi", cache_control: { type: "ephemeral" } }] }],
@@ -48,15 +48,12 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  it.effect("'auto' marks the last tool, first and last system parts, and final message boundary on Anthropic", () =>
+  it.effect("'auto' marks the last tool, last system part, and latest user message on Anthropic", () =>
     Effect.gen(function* () {
       const prepared = yield* LLMClient.prepare(
         LLM.request({
           model: anthropicModel,
-          system: [
-            { type: "text", text: "Base agent" },
-            { type: "text", text: "Project instructions" },
-          ],
+          system: "Sys A",
           tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
           messages: [
             Message.user("first user"),
@@ -69,10 +66,7 @@ describe("applyCachePolicy", () => {
 
       expect(prepared.body).toMatchObject({
         tools: [{ name: "t1", cache_control: { type: "ephemeral" } }],
-        system: [
-          { type: "text", text: "Base agent", cache_control: { type: "ephemeral" } },
-          { type: "text", text: "Project instructions", cache_control: { type: "ephemeral" } },
-        ],
+        system: [{ type: "text", text: "Sys A", cache_control: { type: "ephemeral" } }],
         messages: [
           { role: "user", content: [{ type: "text", text: "first user" }] },
           { role: "assistant", content: [{ type: "text", text: "assistant reply" }] },
@@ -126,10 +120,7 @@ describe("applyCachePolicy", () => {
       const prepared = yield* LLMClient.prepare(
         LLM.request({
           model: bedrockModel,
-          system: [
-            { type: "text", text: "Base agent" },
-            { type: "text", text: "Project instructions" },
-          ],
+          system: "Sys",
           tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
           messages: [Message.user("first user"), Message.assistant("reply"), Message.user("latest user")],
           cache: "auto",
@@ -140,12 +131,7 @@ describe("applyCachePolicy", () => {
         toolConfig: {
           tools: [{ toolSpec: { name: "t1" } }, { cachePoint: { type: "default" } }],
         },
-        system: [
-          { text: "Base agent" },
-          { cachePoint: { type: "default" } },
-          { text: "Project instructions" },
-          { cachePoint: { type: "default" } },
-        ],
+        system: [{ text: "Sys" }, { cachePoint: { type: "default" } }],
         messages: [
           { role: "user", content: [{ text: "first user" }] },
           { role: "assistant", content: [{ text: "reply" }] },
@@ -207,55 +193,9 @@ describe("applyCachePolicy", () => {
         }),
       )
 
-      const body = prepared.body as {
-        system: Array<{ text: string; cache_control?: unknown }>
-        messages: Array<{ content: Array<{ cache_control?: unknown }> }>
-      }
+      const body = prepared.body as { system: Array<{ text: string; cache_control?: unknown }> }
       expect(body.system[0]?.cache_control).toEqual({ type: "ephemeral", ttl: "1h" })
       expect(body.system[1]?.cache_control).toEqual({ type: "ephemeral" })
-      expect(body.messages[0]?.content[0]?.cache_control).toEqual({ type: "ephemeral" })
-    }),
-  )
-
-  it.effect("auto policy stays within the four-breakpoint cap when preserving manual hints", () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model: anthropicModel,
-        system: [
-          { type: "text", text: "Base agent" },
-          {
-            type: "text",
-            text: "Manual context",
-            cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3600 }),
-          },
-          { type: "text", text: "Project instructions" },
-        ],
-        tools: [{ name: "t1", description: "t1", inputSchema: { type: "object", properties: {} } }],
-        prompt: "hi",
-        cache: "auto",
-      })
-      const applied = applyCachePolicy(request)
-      expect(applied.tools[0]?.cache).toBeDefined()
-      expect(applied.system.map((part) => part.cache !== undefined)).toEqual([true, true, true])
-      const tail = applied.messages[0]!.content[0]!
-      expect("cache" in tail ? tail.cache : undefined).toBeUndefined()
-      expect(applyCachePolicy(applied)).toBe(applied)
-
-      const prepared = yield* LLMClient.prepare(request)
-
-      const body = prepared.body as {
-        tools: Array<{ cache_control?: unknown }>
-        system: Array<{ cache_control?: unknown }>
-        messages: Array<{ content: Array<{ cache_control?: unknown }> }>
-      }
-      const marked = [
-        ...body.tools.map((tool) => tool.cache_control),
-        ...body.system.map((part) => part.cache_control),
-        ...body.messages.flatMap((message) => message.content.map((part) => part.cache_control)),
-      ].filter((cache) => cache !== undefined)
-      expect(marked).toHaveLength(4)
-      expect(body.system[1]?.cache_control).toEqual({ type: "ephemeral", ttl: "1h" })
-      expect(body.messages[0]?.content[0]?.cache_control).toBeUndefined()
     }),
   )
 

packages/ai/test/provider/anthropic-messages-cache.recorded.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { CacheHint, LLM, LLMRequest, Message, ToolCallPart, ToolDefinition } from "../../src"
+import { CacheHint, LLM } from "../../src"
 import { LLMClient } from "../../src/route"
 import * as Anthropic from "../../src/providers/anthropic"
 import { LARGE_CACHEABLE_SYSTEM } from "../recorded-scenarios"
@@ -24,39 +24,6 @@ const cacheRequest = LLM.request({
   generation: { maxTokens: 16, temperature: 0 },
 })
 
-const lookup = ToolDefinition.make({
-  name: "lookup",
-  description: "Look up a fixture value.",
-  inputSchema: {
-    type: "object",
-    properties: { index: { type: "number" } },
-    required: ["index"],
-    additionalProperties: false,
-  },
-})
-const longToolTurn = [
-  Message.user("Run the fixture lookups."),
-  ...Array.from({ length: 11 }, (_, index) => {
-    const id = `lookup_${index}`
-    return [
-      Message.assistant(ToolCallPart.make({ id, name: lookup.name, input: { index } })),
-      Message.tool({
-        id,
-        name: lookup.name,
-        result: `Fixture result ${index}. `.repeat(80),
-      }),
-    ]
-  }).flat(),
-]
-const longToolTurnRequest = LLM.request({
-  id: "recorded_anthropic_cache_long_tool_turn",
-  model,
-  system: LARGE_CACHEABLE_SYSTEM,
-  messages: longToolTurn,
-  tools: [lookup],
-  generation: { maxTokens: 16, temperature: 0 },
-})
-
 const recorded = recordedTests({
   prefix: "anthropic-messages-cache",
   provider: "anthropic",
@@ -83,28 +50,4 @@ describe("Anthropic Messages cache recorded", () => {
       expect(second.usage?.cacheReadInputTokens ?? 0).toBeGreaterThan(0)
     }),
   )
-
-  recorded.effect.with("keeps a long tool turn inside the cache lookback", { tags: ["cache", "tool"] }, () =>
-    Effect.gen(function* () {
-      const first = yield* LLMClient.generate(longToolTurnRequest)
-      const firstRead = first.usage?.cacheReadInputTokens ?? 0
-      const firstWrite = first.usage?.cacheWriteInputTokens ?? 0
-      const firstCached = firstRead + firstWrite
-      // The prefix may already be warm when recording, so either a read or a
-      // write establishes that Anthropic recognized the cache boundary.
-      expect(firstCached).toBeGreaterThan(0)
-
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(longToolTurnRequest, {
-          messages: [
-            ...longToolTurn,
-            Message.assistant("The fixture lookups are complete."),
-            Message.user("Reply exactly: OK"),
-          ],
-        }),
-      )
-      expect(second.usage?.cacheReadInputTokens ?? 0).toBeGreaterThanOrEqual(firstCached)
-      expect(second.usage?.cacheWriteInputTokens ?? 0).toBeLessThan(firstCached)
-    }),
-  )
 })

packages/ai/test/provider/anthropic-messages.test.ts

@@ -506,7 +506,6 @@ describe("Anthropic Messages route", () => {
       expect(response.events.find((event) => event.type === "reasoning-end")).toMatchObject({
         providerMetadata: { anthropic: { signature: "sig_1" } },
       })
-      expect(response.events.find((event) => event.type === "reasoning-delta" && event.text === "")).toBeUndefined()
       expect(response.message.content).toEqual([
         { type: "text", text: "Hello!" },
         { type: "reasoning", text: "thinking", providerMetadata: { anthropic: { signature: "sig_1" } } },
@@ -519,199 +518,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("requires message_stop before completing a streamed message", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
-              { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Hello" } },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidProviderOutput",
-        message: "Provider stream ended without a terminal finish event",
-      })
-    }),
-  )
-
-  it.effect("maps thinking tokens and preserves unknown Anthropic usage fields", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "message_start",
-                message: {
-                  usage: {
-                    input_tokens: 5,
-                    cache_read_input_tokens: 2,
-                    service_tier: "standard",
-                    cache_creation: { ephemeral_5m_input_tokens: 1 },
-                    server_tool_use: { web_search_requests: 1, start_counter: 2 },
-                    output_tokens_details: { thinking_tokens: 3, start_detail: "preserved" },
-                  },
-                },
-              },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "end_turn" },
-                usage: {
-                  output_tokens: 8,
-                  server_tool_use: { web_search_requests: 2, terminal_counter: 3 },
-                  output_tokens_details: { terminal_detail: "preserved" },
-                  future_terminal: { requests: 4 },
-                },
-              },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.usage).toMatchObject({
-        inputTokens: 7,
-        outputTokens: 8,
-        reasoningTokens: 3,
-        totalTokens: 15,
-        providerMetadata: {
-          anthropic: {
-            input_tokens: 5,
-            cache_read_input_tokens: 2,
-            service_tier: "standard",
-            cache_creation: { ephemeral_5m_input_tokens: 1 },
-            server_tool_use: { web_search_requests: 2, start_counter: 2, terminal_counter: 3 },
-            output_tokens: 8,
-            output_tokens_details: {
-              thinking_tokens: 3,
-              start_detail: "preserved",
-              terminal_detail: "preserved",
-            },
-            future_terminal: { requests: 4 },
-          },
-        },
-      })
-    }),
-  )
-
-  it.effect("round-trips omitted thinking carried only by a signature delta", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "thinking", thinking: "", signature: "" },
-              },
-              { type: "content_block_delta", index: 0, delta: { type: "signature_delta", signature: "sig_1" } },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { anthropic: { signature: "sig_1" } } },
-      ])
-
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({ model, messages: [response.message], cache: "none" }),
-      )
-      expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: [{ type: "thinking", thinking: "", signature: "sig_1" }] },
-      ])
-    }),
-  )
-
-  it.effect("retains a thinking signature supplied in content_block_start", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "thinking", thinking: "", signature: "sig_1" },
-              },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { anthropic: { signature: "sig_1" } } },
-      ])
-      expect(response.events.find((event) => event.type === "reasoning-end")).toMatchObject({
-        providerMetadata: { anthropic: { signature: "sig_1" } },
-      })
-    }),
-  )
-
-  it.effect("retains complete tool input from content_block_start", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "tool_use", id: "call_1", name: "lookup", input: { query: "weather" } },
-              },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.toolCalls).toMatchObject([
-        { id: "call_1", name: "lookup", input: { query: "weather" } },
-      ])
-    }),
-  )
-
-  it.effect("retains empty text blocks", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } },
-              { type: "content_block_stop", index: 0 },
-              { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([{ type: "text", text: "" }])
-    }),
-  )
-
   it.effect("parses redacted thinking into empty reasoning with redactedData metadata", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -823,7 +629,6 @@ describe("Anthropic Messages route", () => {
                 delta: { stop_reason: "model_context_window_exceeded" },
                 usage: { output_tokens: 1 },
               },
-              { type: "message_stop" },
             ),
           ),
         ),
@@ -841,7 +646,6 @@ describe("Anthropic Messages route", () => {
             sseEvents(
               { type: "message_start", message: { usage: { input_tokens: 5 } } },
               { type: "message_delta", delta: { stop_reason: "pause_turn" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
             ),
           ),
         ),
@@ -860,7 +664,6 @@ describe("Anthropic Messages route", () => {
         { type: "content_block_delta", index: 0, delta: { type: "input_json_delta", partial_json: ':"weather"}' } },
         { type: "content_block_stop", index: 0 },
         { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 1 } },
-        { type: "message_stop" },
       )
       const response = yield* LLMClient.generate(
         LLMRequest.update(request, {
@@ -1046,7 +849,6 @@ describe("Anthropic Messages route", () => {
         { type: "content_block_delta", index: 2, delta: { type: "text_delta", text: "Found it." } },
         { type: "content_block_stop", index: 2 },
         { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 8 } },
-        { type: "message_stop" },
       )
       const response = yield* LLMClient.generate(
         LLMRequest.update(request, {
@@ -1110,7 +912,6 @@ describe("Anthropic Messages route", () => {
         },
         { type: "content_block_stop", index: 1 },
         { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-        { type: "message_stop" },
       )
       const response = yield* LLMClient.generate(
         LLMRequest.update(request, {

packages/ai/test/provider/bedrock-converse.test.ts

@@ -939,7 +939,6 @@ describe("Bedrock Converse route", () => {
       const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
         LLM.request({
           model,
-          cache: "none",
           messages: [
             Message.assistant([ToolCallPart.make({ id: "call_1", name: "read", input: { path: "report.pdf" } })]),
             Message.tool({

packages/ai/test/provider/openai-chat.test.ts

@@ -550,7 +550,7 @@ describe("OpenAI Chat route", () => {
           prompt_tokens: 5,
           completion_tokens: 2,
           total_tokens: 7,
-          prompt_tokens_details: { cached_tokens: 1, cache_write_tokens: 2 },
+          prompt_tokens_details: { cached_tokens: 1 },
           completion_tokens_details: { reasoning_tokens: 0 },
         }),
       )
@@ -558,9 +558,8 @@ describe("OpenAI Chat route", () => {
       const usage = new Usage({
         inputTokens: 5,
         outputTokens: 2,
-        nonCachedInputTokens: 2,
+        nonCachedInputTokens: 4,
         cacheReadInputTokens: 1,
-        cacheWriteInputTokens: 2,
         reasoningTokens: 0,
         totalTokens: 7,
         providerMetadata: {
@@ -568,7 +567,7 @@ describe("OpenAI Chat route", () => {
             prompt_tokens: 5,
             completion_tokens: 2,
             total_tokens: 7,
-            prompt_tokens_details: { cached_tokens: 1, cache_write_tokens: 2 },
+            prompt_tokens_details: { cached_tokens: 1 },
             completion_tokens_details: { reasoning_tokens: 0 },
           },
         },

packages/ai/test/provider/openai-compatible-responses.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { Effect } from "effect"
-import { LLM, LLMEvent, Message } from "../../src"
+import { LLM, LLMEvent } from "../../src"
 import { configure } from "../../src/providers/openai-compatible-responses"
 import { OpenAI } from "../../src/providers"
 import { OpenResponses } from "../../src/protocols/open-responses"
@@ -70,31 +70,6 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
-  it.effect("omits OpenAI-only nullable phases from the Open Responses baseline", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-      }).model("example-model")
-      const prepared = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant({
-              type: "text",
-              text: "Unclassified.",
-              providerMetadata: { openresponses: { phase: null } },
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        input: [{ role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
-      })
-    }),
-  )
-
   it.effect("reads standard options from the Open Responses namespace", () =>
     Effect.gen(function* () {
       const model = configure({

packages/ai/test/provider/openai-responses.test.ts

@@ -832,7 +832,7 @@ describe("OpenAI Responses route", () => {
               input_tokens: 5,
               output_tokens: 2,
               total_tokens: 7,
-              input_tokens_details: { cached_tokens: 1, cache_write_tokens: 2 },
+              input_tokens_details: { cached_tokens: 1 },
               output_tokens_details: { reasoning_tokens: 0 },
             },
           },
@@ -842,9 +842,8 @@ describe("OpenAI Responses route", () => {
       const usage = new Usage({
         inputTokens: 5,
         outputTokens: 2,
-        nonCachedInputTokens: 2,
+        nonCachedInputTokens: 4,
         cacheReadInputTokens: 1,
-        cacheWriteInputTokens: 2,
         reasoningTokens: 0,
         totalTokens: 7,
         providerMetadata: {
@@ -852,7 +851,7 @@ describe("OpenAI Responses route", () => {
             input_tokens: 5,
             output_tokens: 2,
             total_tokens: 7,
-            input_tokens_details: { cached_tokens: 1, cache_write_tokens: 2 },
+            input_tokens_details: { cached_tokens: 1 },
             output_tokens_details: { reasoning_tokens: 0 },
           },
         },
@@ -882,121 +881,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("preserves and replays assistant message phases", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                item: { type: "message", id: "msg_commentary" },
-              },
-              { type: "response.output_text.delta", item_id: "msg_commentary", delta: "Checking." },
-              { type: "response.output_text.done", item_id: "msg_commentary" },
-              {
-                type: "response.output_item.done",
-                item: { type: "message", id: "msg_commentary", phase: "commentary" },
-              },
-              {
-                type: "response.output_item.added",
-                item: { type: "message", id: "msg_final", phase: "final_answer" },
-              },
-              { type: "response.output_text.done", item_id: "msg_final", text: "Finished." },
-              {
-                type: "response.output_item.done",
-                item: { type: "message", id: "msg_final", phase: "final_answer" },
-              },
-              { type: "response.output_item.added", item: { type: "message", id: "msg_null", phase: null } },
-              { type: "response.output_text.delta", item_id: "msg_null", delta: "Unclassified." },
-              { type: "response.output_item.done", item: { type: "message", id: "msg_null", phase: null } },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "Checking.",
-          providerMetadata: { openai: { phase: "commentary" } },
-        },
-        {
-          type: "text",
-          text: "Finished.",
-          providerMetadata: { openai: { phase: "final_answer" } },
-        },
-        {
-          type: "text",
-          text: "Unclassified.",
-          providerMetadata: { openai: { phase: null } },
-        },
-      ])
-
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
-      expect(prepared.body.input).toEqual([
-        {
-          role: "assistant",
-          content: [{ type: "output_text", text: "Checking." }],
-          phase: "commentary",
-        },
-        {
-          role: "assistant",
-          content: [{ type: "output_text", text: "Finished." }],
-          phase: "final_answer",
-        },
-        {
-          role: "assistant",
-          content: [{ type: "output_text", text: "Unclassified." }],
-          phase: null,
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects output text events without the spec-required item id", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_text.delta", delta: "orphaned" },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("response.output_text.delta is missing item_id")
-    }),
-  )
-
-  it.effect("rejects reasoning events without the spec-required item id", () =>
-    Effect.gen(function* () {
-      const events = [
-        { type: "response.reasoning_summary_part.added", summary_index: 0 },
-        { type: "response.reasoning_summary_part.done", summary_index: 0 },
-        { type: "response.reasoning_text.done" },
-      ]
-
-      for (const event of events) {
-        const error = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(sseEvents(event, { type: "response.completed", response: { id: "resp_1" } })),
-          ),
-          Effect.flip,
-        )
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-        expect(error.message).toContain(`${event.type} is missing item_id`)
-      }
-    }),
-  )
-
   it.effect("maps incomplete response reasons", () =>
     Effect.gen(function* () {
       const generate = (incompleteDetails: object) =>

packages/ai/test/tool-runtime.test.ts

@@ -539,7 +539,6 @@ describe("LLMClient tools", () => {
                   },
                   { type: "content_block_stop", index: 1 },
                   { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 5 } },
-                  { type: "message_stop" },
                 )
               : sseEvents(
                   { type: "message_start", message: { usage: { input_tokens: 5 } } },
@@ -547,7 +546,6 @@ describe("LLMClient tools", () => {
                   { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "Done." } },
                   { type: "content_block_stop", index: 0 },
                   { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 1 } },
-                  { type: "message_stop" },
                 ),
             { headers: { "content-type": "text/event-stream" } },
           )
@@ -803,7 +801,6 @@ describe("LLMClient tools", () => {
               { type: "content_block_delta", index: 2, delta: { type: "text_delta", text: "Done." } },
               { type: "content_block_stop", index: 2 },
               { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 8 } },
-              { type: "message_stop" },
             ),
             { headers: { "content-type": "text/event-stream" } },
           )

packages/client/src/effect/api.ts

@@ -1,9 +1,7 @@
-import type { ModelApi, ProviderApi, WebsearchApi } from "./api/api.js"
+import type { ModelApi, ProviderApi } 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

@@ -1042,25 +1042,6 @@ export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
 }
 
-type Endpoint27_0Request = Parameters<RawClient["server.websearch"]["websearch.providers"]>[0]
-export type Endpoint27_0Input = { readonly location?: Endpoint27_0Request["query"]["location"] }
-export type Endpoint27_0Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.providers"]>>
-export type WebsearchProvidersOperation<E = never> = (input?: Endpoint27_0Input) => Effect.Effect<Endpoint27_0Output, E>
-
-type Endpoint27_1Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
-export type Endpoint27_1Input = {
-  readonly location?: Endpoint27_1Request["query"]["location"]
-  readonly query: Endpoint27_1Request["payload"]["query"]
-  readonly providerID?: Endpoint27_1Request["payload"]["providerID"]
-}
-export type Endpoint27_1Output = EffectValue<ReturnType<RawClient["server.websearch"]["websearch.query"]>>
-export type WebsearchQueryOperation<E = never> = (input: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>
-
-export interface WebsearchApi<E = never> {
-  readonly providers: WebsearchProvidersOperation<E>
-  readonly query: WebsearchQueryOperation<E>
-}
-
 export interface AppApi<E = never> {
   readonly health: HealthApi<E>
   readonly server: ServerApi<E>
@@ -1089,5 +1070,4 @@ 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

@@ -1244,28 +1244,6 @@ const adaptGroup26 = (raw: RawClient["server.debug"]) => ({
   location: { list: Endpoint26_0(raw), evict: Endpoint26_1(raw) },
 })
 
-type Endpoint27_0Request = Parameters<RawClient["server.websearch"]["websearch.providers"]>[0]
-type Endpoint27_0Input = { readonly location?: Endpoint27_0Request["query"]["location"] }
-const Endpoint27_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint27_0Input) =>
-  raw["websearch.providers"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError))
-
-type Endpoint27_1Request = Parameters<RawClient["server.websearch"]["websearch.query"]>[0]
-type Endpoint27_1Input = {
-  readonly location?: Endpoint27_1Request["query"]["location"]
-  readonly query: Endpoint27_1Request["payload"]["query"]
-  readonly providerID?: Endpoint27_1Request["payload"]["providerID"]
-}
-const Endpoint27_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint27_1Input) =>
-  raw["websearch.query"]({
-    query: { location: input["location"] },
-    payload: { query: input["query"], providerID: input["providerID"] },
-  }).pipe(Effect.mapError(mapClientError))
-
-const adaptGroup27 = (raw: RawClient["server.websearch"]) => ({
-  providers: Endpoint27_0(raw),
-  query: Endpoint27_1(raw),
-})
-
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
   server: adaptGroup1(raw["server.server"]),
@@ -1294,7 +1272,6 @@ const adaptClient = (raw: RawClient) => ({
   projectCopy: adaptGroup24(raw["server.projectCopy"]),
   vcs: adaptGroup25(raw["server.vcs"]),
   debug: adaptGroup26(raw["server.debug"]),
-  websearch: adaptGroup27(raw["server.websearch"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/effect/index.ts

@@ -14,7 +14,6 @@ export type {
   PluginApi,
   ProviderApi,
   ReferenceApi,
-  WebSearchApi,
   SessionApi,
   SkillApi,
 } from "./api.js"
@@ -36,7 +35,6 @@ 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 { SessionPending } from "@opencode-ai/schema/session-pending"

packages/client/src/promise/api.ts

@@ -8,7 +8,6 @@ export type ModelApi = Client["model"]
 export type PluginApi = Client["plugin"]
 export type ProviderApi = Client["provider"]
 export type ReferenceApi = Client["reference"]
-export type WebSearchApi = Client["websearch"]
 export type SessionApi = Client["session"]
 export type SkillApi = Client["skill"]
 

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

@@ -207,10 +207,6 @@ import type {
   DebugLocationListOutput,
   DebugLocationEvictInput,
   DebugLocationEvictOutput,
-  WebsearchProvidersInput,
-  WebsearchProvidersOutput,
-  WebsearchQueryInput,
-  WebsearchQueryOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -1739,33 +1735,6 @@ export function make(options: ClientOptions) {
           ),
       },
     },
-    websearch: {
-      providers: (input?: WebsearchProvidersInput, requestOptions?: RequestOptions) =>
-        request<WebsearchProvidersOutput>(
-          {
-            method: "GET",
-            path: `/api/websearch/provider`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [503, 401, 400],
-            empty: false,
-          },
-          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

@@ -98,6 +98,8 @@ export type SessionMessageShell = {
   output?: { output: string; cursor: number; size: number; truncated: boolean }
 }
 
+export type SessionMessageAssistantText = { type: "text"; text: string }
+
 export type SessionMessageProviderState = { [x: string]: JsonValue }
 
 export type SessionMessageToolStateStreaming = { status: "streaming"; input: string }
@@ -155,6 +157,8 @@ export type ShellInfo = {
   time: { started: number; completed?: number }
 }
 
+export type SessionMessageProviderState3 = { [x: string]: any }
+
 export type SessionMessageProviderState4 = { [x: string]: any }
 
 export type SessionMessageProviderState5 = { [x: string]: any }
@@ -163,10 +167,6 @@ export type SessionMessageProviderState6 = { [x: string]: any }
 
 export type SessionMessageProviderState7 = { [x: string]: any }
 
-export type SessionMessageProviderState8 = { [x: string]: any }
-
-export type SessionMessageProviderState9 = { [x: string]: any }
-
 export type EventLogSynced = { type: "log.synced"; aggregateID: string; seq?: number }
 
 export type ModelReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {})
@@ -539,10 +539,6 @@ export type VcsFileStatus = {
   status: "added" | "deleted" | "modified"
 }
 
-export type WebSearchProvider = { id: string; name: string }
-
-export type WebSearchResult = { url: string; title?: string; content?: string; time: { published?: number } }
-
 export type SessionMessageModelSelected = {
   id: string
   metadata?: { [x: string]: JsonValue }
@@ -737,6 +733,16 @@ export type SessionTextStarted = {
   data: { sessionID: string; assistantMessageID: string; ordinal: number }
 }
 
+export type SessionTextEnded = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.text.ended"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; assistantMessageID: string; ordinal: number; text: string }
+}
+
 export type SessionToolInputStarted = {
   id: string
   created: number
@@ -1062,15 +1068,6 @@ export type FormCancelled = {
   data: { id: string; sessionID: string }
 }
 
-export type WebsearchUpdated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "websearch.updated"
-  location?: LocationRef
-  data: {}
-}
-
 export type SessionIdle = {
   id: string
   created: number
@@ -1252,8 +1249,6 @@ export type SessionPendingSynthetic = {
   delivery: "steer" | "queue"
 }
 
-export type SessionMessageAssistantText = { type: "text"; text: string; state?: SessionMessageProviderState }
-
 export type SessionMessageAssistantReasoning = {
   type: "reasoning"
   text: string
@@ -1364,22 +1359,6 @@ export type ShellCreated = {
   data: { info: ShellInfo }
 }
 
-export type SessionTextEnded = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "session.text.ended"
-  durable: { aggregateID: string; seq: number; version: 1 }
-  location?: LocationRef
-  data: {
-    sessionID: string
-    assistantMessageID: string
-    ordinal: number
-    text: string
-    state?: SessionMessageProviderState4
-  }
-}
-
 export type SessionReasoningStarted = {
   id: string
   created: number
@@ -1387,7 +1366,7 @@ export type SessionReasoningStarted = {
   type: "session.reasoning.started"
   durable: { aggregateID: string; seq: number; version: 1 }
   location?: LocationRef
-  data: { sessionID: string; assistantMessageID: string; ordinal: number; state?: SessionMessageProviderState5 }
+  data: { sessionID: string; assistantMessageID: string; ordinal: number; state?: SessionMessageProviderState3 }
 }
 
 export type SessionReasoningEnded = {
@@ -1402,7 +1381,7 @@ export type SessionReasoningEnded = {
     assistantMessageID: string
     ordinal: number
     text: string
-    state?: SessionMessageProviderState6
+    state?: SessionMessageProviderState4
   }
 }
 
@@ -1419,7 +1398,7 @@ export type SessionToolCalled = {
     callID: string
     input: { [x: string]: any }
     executed: boolean
-    state?: SessionMessageProviderState7
+    state?: SessionMessageProviderState5
   }
 }
 
@@ -1874,7 +1853,7 @@ export type SessionToolSuccess = {
     content: [LLMToolContent, ...Array<LLMToolContent>]
     metadata?: { [x: string]: JsonValue }
     executed: boolean
-    resultState?: SessionMessageProviderState8
+    resultState?: SessionMessageProviderState6
   }
 }
 
@@ -1893,7 +1872,7 @@ export type SessionToolFailed = {
     content?: [LLMToolContent, ...Array<LLMToolContent>]
     metadata?: { [x: string]: JsonValue }
     executed: boolean
-    resultState?: SessionMessageProviderState9
+    resultState?: SessionMessageProviderState7
   }
 }
 
@@ -2368,7 +2347,6 @@ export type V2Event =
   | FormCreated
   | FormReplied
   | FormCancelled
-  | WebsearchUpdated
   | SessionStatus2
   | SessionIdle
   | TuiPromptAppend
@@ -4972,27 +4950,3 @@ export type DebugLocationEvictInput = {
 }
 
 export type DebugLocationEvictOutput = void
-
-export type WebsearchProvidersInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
-
-export type WebsearchProvidersOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string } }
-  data: Array<WebSearchProvider>
-}
-
-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 = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string } }
-  data: { providerID: string; results: Array<WebSearchResult> }
-}

packages/client/src/promise/index.ts

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

packages/client/test/promise.test.ts

@@ -32,7 +32,6 @@ 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"])
@@ -42,7 +41,6 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.integration.connect)).toEqual(["key"])
   expect(Object.keys(client.integration.oauth)).toEqual(["connect", "status", "complete", "cancel"])
   expect(Object.keys(client.integration.command)).toEqual(["connect", "status", "cancel"])
-  expect(Object.keys(client.websearch)).toEqual(["providers", "query"])
   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"])
@@ -50,37 +48,6 @@ 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",
-          results: [{ url: "https://example.com", title: "Result", content: "result", time: {} }],
-        },
-      })
-    },
-  })
-
-  const result = await client.websearch.query({
-    query: "opencode",
-    providerID: "exa",
-    location: { directory: "/tmp/project" },
-  })
-
-  expect(result.data).toEqual({
-    providerID: "exa",
-    results: [{ url: "https://example.com", title: "Result", content: "result", time: {} }],
-  })
-  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("server.get uses the public HTTP contract", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/codemode/src/codemode.ts

@@ -40,7 +40,7 @@ export type ExecuteOptions<Provided extends Record<string, unknown> = {}> = {
   limits?: ExecutionLimits
   /** Observes decoded tool input immediately before tool execution. */
   onToolCallStart?: (call: ToolRuntime.ToolCallStarted) => Effect.Effect<void, never, Services<Provided>>
-  /** Observes each admitted tool call as it succeeds, fails, or is interrupted. */
+  /** Observes each admitted tool call as it settles, with outcome and duration. */
   onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Provided>>
 }
 

packages/codemode/src/tool-runtime.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Exit, Schema } from "effect"
+import { Cause, Effect, Schema } from "effect"
 import { ToolError, toolError } from "./tool-error.js"
 import {
   decodeInput as decodeToolInput,
@@ -52,7 +52,7 @@ export type ToolCallEnded = {
   readonly name: string
   readonly input: unknown
   readonly durationMs: number
-  readonly outcome: "success" | "failure" | "interrupted"
+  readonly outcome: "success" | "failure"
   readonly message?: string
 }
 
@@ -342,6 +342,7 @@ export type DiscoveryPlan = {
 
 export type SearchEntry = {
   readonly description: ToolDescription
+  readonly namespace: string
   readonly searchText: string
 }
 
@@ -372,11 +373,7 @@ const makeSearchTool = (searchIndex: ReadonlyArray<SearchEntry>): Tool => ({
       const scoped =
         request.namespace === undefined
           ? searchIndex
-          : searchIndex.filter(
-              (entry) =>
-                entry.description.path === request.namespace ||
-                entry.description.path.startsWith(`${request.namespace}.`),
-            )
+          : searchIndex.filter((entry) => entry.namespace === request.namespace)
       const trimmed = query.trim()
       const pathQuery = trimmed.startsWith("tools.") ? trimmed.slice("tools.".length) : trimmed
       const exact =
@@ -431,6 +428,7 @@ export const searchSignature = (() => {
 
 const toSearchEntry = <R>(path: string, tool: Tool<R>, description: ToolDescription): SearchEntry => ({
   description,
+  namespace: path.split(".", 1)[0]!,
   searchText: [
     path,
     tool.description,
@@ -497,19 +495,22 @@ export const make = <R>(
   const root = toolTrie(tools)
   const searchTool = makeSearchTool(searchIndex)
 
+  // End hooks observe settled success or failure; interruption emits neither outcome.
   const observeEnd = <A, E>(effect: Effect.Effect<A, E, R>, call: ToolCallStarted): Effect.Effect<A, E, R> => {
     const onEnd = hooks?.onToolCallEnd
     if (onEnd === undefined) return effect
     const startedAt = Date.now()
     return effect.pipe(
-      Effect.onExit((exit) => {
-        const durationMs = Date.now() - startedAt
-        if (Exit.isSuccess(exit)) return onEnd({ ...call, durationMs, outcome: "success" })
-        if (Cause.hasInterruptsOnly(exit.cause)) return onEnd({ ...call, durationMs, outcome: "interrupted" })
-        const error = Cause.squash(exit.cause)
+      Effect.tap(() => onEnd({ ...call, durationMs: Date.now() - startedAt, outcome: "success" })),
+      Effect.tapError((error) => {
         const message =
           error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
-        return onEnd({ ...call, durationMs, outcome: "failure", message })
+        return onEnd({
+          ...call,
+          durationMs: Date.now() - startedAt,
+          outcome: "failure",
+          message,
+        })
       }),
     )
   }
@@ -527,6 +528,12 @@ export const make = <R>(
     calls.push(call)
   }
 
+  const recordAndObserve = (name: string, input: unknown) =>
+    Effect.sync(() => {
+      recordCall({ name })
+      return calls.length - 1
+    }).pipe(Effect.tap((index) => hooks?.onToolCallStart?.({ index, name, input }) ?? Effect.void))
+
   const executeTool = (name: string, tool: Tool<R>, externalArgs: Array<unknown>) =>
     Effect.gen(function* () {
       if (externalArgs.length !== 1)
@@ -540,14 +547,9 @@ export const make = <R>(
             name === "search" ? [] : ["The signature may have changed. Use search to get the current signature."],
           ),
       })
-      const index = yield* Effect.sync(() => {
-        recordCall({ name })
-        return calls.length - 1
-      })
-      const call = { index, name, input }
+      const index = yield* recordAndObserve(name, input)
       return yield* observeEnd(
         Effect.gen(function* () {
-          if (hooks?.onToolCallStart !== undefined) yield* hooks.onToolCallStart(call)
           const raw = yield* runHost(Effect.suspend(() => tool.execute(input)))
           const result = yield* Effect.try({
             try: () => decodeToolOutput(tool, raw),
@@ -555,7 +557,7 @@ export const make = <R>(
           })
           return yield* decodeOutput(result, name)
         }),
-        call,
+        { index, name, input },
       )
     })
 

packages/codemode/test/codemode.test.ts

@@ -189,12 +189,7 @@ describe("CodeMode tool-call observation", () => {
       description: "Look up a value",
       input: Schema.Struct({ query: Schema.String }),
       output: Schema.String,
-      execute: ({ query }) =>
-        query === "boom"
-          ? Effect.fail(toolError("Lookup refused"))
-          : query === "defect"
-            ? Effect.die("broken")
-            : Effect.succeed(query),
+      execute: ({ query }) => (query === "boom" ? Effect.fail(toolError("Lookup refused")) : Effect.succeed(query)),
     })
 
     const runtime = CodeMode.make({
@@ -220,98 +215,14 @@ describe("CodeMode tool-call observation", () => {
     expect(success.ok).toBe(true)
     const failure = await Effect.runPromise(runtime.execute(`return await tools.context.lookup({ query: "boom" })`))
     expect(failure.ok).toBe(false)
-    const defect = await Effect.runPromise(runtime.execute(`return await tools.context.lookup({ query: "defect" })`))
-    expect(defect.ok).toBe(false)
 
     expect(events).toStrictEqual([
       { phase: "start", index: 0, name: "context.lookup" },
       { phase: "end", index: 0, name: "context.lookup", outcome: "success" },
       { phase: "start", index: 0, name: "context.lookup" },
       { phase: "end", index: 0, name: "context.lookup", outcome: "failure", message: "Lookup refused" },
-      { phase: "start", index: 0, name: "context.lookup" },
-      { phase: "end", index: 0, name: "context.lookup", outcome: "failure", message: "Tool execution failed" },
     ])
   })
-
-  test("observes interrupted calls", async () => {
-    const events: Array<string> = []
-    const call = Tool.make({
-      description: "Interrupt",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.interrupt,
-    })
-    const exit = await Effect.runPromiseExit(
-      CodeMode.make({
-        tools: { host: { call } },
-        onToolCallStart: () => Effect.sync(() => events.push("start")),
-        onToolCallEnd: (call) => Effect.sync(() => events.push(`end:${call.outcome}`)),
-      }).execute("return await tools.host.call({})"),
-    )
-
-    expect(exit._tag).toBe("Failure")
-    expect(events).toEqual(["start", "end:interrupted"])
-  })
-
-  test("observes running calls interrupted during completion", async () => {
-    const events: Array<string> = []
-    const call = Tool.make({
-      description: "Pending",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.never,
-    })
-    const result = await Effect.runPromise(
-      CodeMode.make({
-        tools: { host: { call } },
-        onToolCallStart: () => Effect.sync(() => events.push("start")),
-        onToolCallEnd: (call) => Effect.sync(() => events.push(`end:${call.outcome}`)),
-      }).execute('tools.host.call({}); return "done"'),
-    )
-
-    expect(result).toMatchObject({ ok: true, value: "done" })
-    expect(events).toEqual(["start", "end:interrupted"])
-  })
-
-  test("ends calls interrupted during start observation", async () => {
-    const events: Array<string> = []
-    const call = Tool.make({
-      description: "Unused",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.succeed("unused"),
-    })
-    const exit = await Effect.runPromiseExit(
-      CodeMode.make({
-        tools: { host: { call } },
-        onToolCallStart: () => Effect.interrupt,
-        onToolCallEnd: (call) => Effect.sync(() => events.push(call.outcome)),
-      }).execute("return await tools.host.call({})"),
-    )
-
-    expect(exit._tag).toBe("Failure")
-    expect(events).toEqual(["interrupted"])
-  })
-
-  test("observes calls interrupted by the execution timeout", async () => {
-    const outcomes: Array<string> = []
-    const call = Tool.make({
-      description: "Pending",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.never,
-    })
-    const result = await Effect.runPromise(
-      CodeMode.make({
-        tools: { host: { call } },
-        limits: { timeoutMs: 10 },
-        onToolCallEnd: (call) => Effect.sync(() => outcomes.push(call.outcome)),
-      }).execute("return await tools.host.call({})"),
-    )
-
-    expect(result).toMatchObject({ ok: false, error: { kind: "TimeoutExceeded" } })
-    expect(outcomes).toEqual(["interrupted"])
-  })
 })
 
 describe("CodeMode console capture", () => {

packages/codemode/test/tool-paths.test.ts

@@ -54,27 +54,6 @@ describe("dotted tool names", () => {
     expect(flat.catalog()[0]?.path).toBe("issues.list")
     expect(await value(flat, `return await tools.issues.list({})`)).toBe("flat")
   })
-
-  test("search scopes to a nested namespace subtree", async () => {
-    const nested = CodeMode.make({
-      tools: {
-        slack: {
-          admin: echo("Admin", "admin"),
-          "admin.invite": echo("Invite", "invite"),
-          "admin.users.list": echo("List users", "users"),
-          "administrator.list": echo("List administrators", "administrators"),
-          read: echo("Read Slack", "read"),
-        },
-      },
-    })
-
-    const result = await value(nested, `return search({ query: "", namespace: "slack.admin" })`)
-    expect((result as { items: Array<{ path: string }> }).items.map((item) => item.path)).toEqual([
-      "tools.slack.admin",
-      "tools.slack.admin.invite",
-      "tools.slack.admin.users.list",
-    ])
-  })
 })
 
 describe("callable namespaces", () => {

packages/core/src/codemode.ts

@@ -63,6 +63,7 @@ const layer = Layer.effect(
           if (rule?.resource === "*" && rule.effect === "deny") continue
           registrations.set(name, registration)
         }
+        if (registrations.size === 0) return {}
         const executeRule = rules.findLast((rule) => Wildcard.match("execute", rule.action))
         if (executeRule?.resource === "*" && executeRule.effect === "deny") return {}
         return {

packages/core/src/codemode/instructions.ts

@@ -6,19 +6,22 @@ import { Instructions } from "../instructions/index"
 import { CodeModeCatalog } from "./catalog"
 
 // prettier-ignore
-const prompt = (hasMoreTools: boolean) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.${hasMoreTools ? `
+const prompt = (hasMoreTools: boolean) => `Run JavaScript to orchestrate tool calls and compose their results. Imports, direct filesystem access, and timers are unavailable. Do not use \`fetch\`; all external access goes through \`tools\`.
+
+Prefer an explicit \`return\`; if omitted, the final top-level expression becomes the result. Await tool calls before returning; any calls still pending when execution ends are interrupted. Run independent calls concurrently with \`Promise.all\`.
+
+Do not infer or normalize tool names; use only the exact signatures shown below${hasMoreTools ? " or returned by `search`" : ""}, preserving bracket notation such as \`tools.<namespace>["tool-name"](input)\`.${hasMoreTools ? `
 
 ## Search
 
-Use \`search\` to discover exact paths and signatures for additional tools:
+Only some tool signatures are shown. Use \`search\` to discover exact paths and signatures for additional tools:
 
 - ${searchSignature}` : ""}
 
 ## Available tools`
 
 export function render(catalog: CodeModeCatalog.Summary) {
-  if (catalog.total === 0)
-    return "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool."
+  if (catalog.total === 0) return "No tools are currently available."
 
   const tools = catalog.namespaces.flatMap((namespace) => {
     const count = namespace.count === 1 ? "1 tool" : `${namespace.count} tools`
@@ -37,13 +40,12 @@ ${tools.join("\n")}`
 }
 
 export function update(previous: CodeModeCatalog.Summary, current: CodeModeCatalog.Summary) {
-  const replacement = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
+  const full = `The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.
 
 ${render(current)}`
-  if (current.total === 0) return replacement
   const previousComplete = previous.shown === previous.total
   const currentComplete = current.shown === current.total
-  if (previousComplete !== currentComplete) return replacement
+  if (previousComplete !== currentComplete) return full
 
   const diff = Instructions.diffByKey(
     previous.namespaces.flatMap((namespace) => namespace.entries),
@@ -54,7 +56,7 @@ ${render(current)}`
   const entriesChanged = diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0
 
   if (!currentComplete) {
-    if (entriesChanged) return replacement
+    if (entriesChanged) return full
     const namespaces = Instructions.diffByKey(
       previous.namespaces,
       current.namespaces,
@@ -62,7 +64,7 @@ ${render(current)}`
       (before, after) => before.count !== after.count,
     )
     const changed = namespaces.added.length > 0 || namespaces.removed.length > 0 || namespaces.changed.length > 0
-    if (!changed) return replacement
+    if (!changed) return full
 
     const parts = ["The Code Mode tool catalog has changed."]
     if (namespaces.added.length > 0) {
@@ -87,11 +89,11 @@ ${render(current)}`
       )
     }
     const delta = parts.join("\n\n")
-    if (delta.length < replacement.length) return delta
-    return replacement
+    if (delta.length < full.length) return delta
+    return full
   }
 
-  if (!entriesChanged) return replacement
+  if (!entriesChanged) return full
   const parts = ["The Code Mode tool catalog has changed."]
   if (diff.added.length > 0) {
     parts.push(
@@ -117,19 +119,19 @@ ${render(current)}`
     )
   }
   const delta = parts.join("\n\n")
-  if (delta.length < replacement.length) return delta
-  return replacement
+  if (delta.length < full.length) return delta
+  return full
 }
 
 const key = Instructions.Key.make("core/codemode")
 const codec = Schema.toCodecJson(CodeModeCatalog.Summary)
 
 export const make = (entries?: ReadonlyArray<CodeModeCatalog.Entry>): Instructions.Instructions => {
-  const catalog = entries === undefined ? Instructions.removed : CodeModeCatalog.summarize(entries)
+  const catalog = CodeModeCatalog.summarize(entries ?? [])
   return Instructions.make({
     key,
     codec,
-    read: Effect.succeed(catalog),
+    read: Effect.succeed(catalog.total === 0 ? Instructions.removed : catalog),
     render: {
       initial: render,
       changed: update,

packages/core/src/config.ts

@@ -27,7 +27,6 @@ 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"
@@ -109,9 +108,6 @@ 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/plugin/websearch.ts

@@ -1,27 +0,0 @@
-export * as ConfigWebSearchPlugin from "./websearch"
-
-import { define } from "@opencode-ai/plugin/v2/effect/plugin"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config"
-
-export const Plugin = define({
-  id: "opencode.config.websearch",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const loaded = { entries: yield* config.entries() }
-    yield* ctx.websearch.transform((websearch) => {
-      const providerID = Config.latest(loaded.entries, "websearch")?.provider
-      if (providerID) websearch.default.set(providerID)
-    })
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(ctx.websearch.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-  }),
-})

packages/core/src/config/websearch.ts

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

packages/core/src/location-services.ts

@@ -29,7 +29,6 @@ import { Pty } from "./pty"
 import { QuestionV2 } from "./question"
 import { Shell } from "./shell"
 import { Reference } from "./reference"
-import { WebSearch } from "./websearch"
 import { ReferenceInstructions } from "./reference/instructions"
 import { SessionRunnerLLM } from "./session/runner/llm"
 import { SessionRunnerModel } from "./session/runner/model"
@@ -57,7 +56,6 @@ const locationServiceNodes = [
   AgentV2.node,
   CommandV2.node,
   Reference.node,
-  WebSearch.node,
   Integration.node,
   Catalog.node,
   ModelResolver.node,

packages/core/src/mcp/instructions.ts

@@ -11,20 +11,16 @@ import { Instructions } from "../instructions/index"
 const Summary = Schema.Struct({
   server: Schema.String,
   instructions: Schema.String,
-  codemode: Schema.optionalKey(Schema.Literal(false)),
 })
 type Summary = typeof Summary.Type
 
 const entries = (servers: ReadonlyArray<Summary>) =>
-  servers.flatMap((server) => {
-    const result = [`  <server name="${server.server}">`]
-    if (server.codemode !== false)
-      result.push(
-        `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.namespace(server.server))}]\`.`,
-      )
-    result.push(...server.instructions.split("\n").map((line) => `    ${line}`), "  </server>")
-    return result
-  })
+  servers.flatMap((server) => [
+    `  <server name="${server.server}">`,
+    `    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(McpTool.namespace(server.server))}]\`.`,
+    ...server.instructions.split("\n").map((line) => `    ${line}`),
+    "  </server>",
+  ])
 
 const render = (servers: ReadonlyArray<Summary>) =>
   ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join("\n")
@@ -34,7 +30,7 @@ const update = (previous: ReadonlyArray<Summary>, current: ReadonlyArray<Summary
     previous,
     current,
     (server) => server.server,
-    (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode,
+    (before, after) => before.instructions !== after.instructions,
   )
   // Additions and removals render as small deltas; anything else restates the full list.
   if (diff.changed.length > 0 || (diff.added.length === 0 && diff.removed.length === 0))
@@ -80,29 +76,21 @@ export const layer = Layer.effect(
               removed: () => "MCP server instructions are no longer available.",
             },
           })
+        if (PermissionV2.evaluate("execute", "*", agent.permissions).effect === "deny")
+          return source(Instructions.removed)
         const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
           concurrency: "unbounded",
         })
-        const canExecute = PermissionV2.evaluate("execute", "*", agent.permissions).effect !== "deny"
         // Instructions are useful only when this agent can reach at least one server tool.
         const visible = instructions
-          .flatMap((item) => {
+          .filter((item) => {
             const owned = tools.filter((tool) => tool.server === item.server)
-            const codemode = owned[0]?.codemode !== false
-            if (codemode && !canExecute) return []
-            if (
-              !owned.some(
-                (tool) =>
-                  PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
-              )
+            return owned.some(
+              (tool) =>
+                PermissionV2.evaluate(McpTool.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny",
             )
-              return []
-            return [
-              codemode
-                ? { server: item.server, instructions: item.instructions }
-                : { server: item.server, instructions: item.instructions, codemode: false as const },
-            ]
           })
+          .map((item) => ({ server: item.server, instructions: item.instructions }))
           .toSorted((a, b) => a.server.localeCompare(b.server))
         return source(visible.length === 0 ? Instructions.removed : visible)
       }),

packages/core/src/permission.ts

@@ -218,11 +218,6 @@ const layer = Layer.effect(
           if (result.effect === "allow") return
           const item = yield* create(request(input), input.agent)
           return yield* restore(Deferred.await(item.deferred)).pipe(
-            // Deliberate defect tunnel: leaves wrap execution in blanket `mapError`, which
-            // must not convert a user's decline into model-facing tool output. The decline
-            // resurfaces as a typed failure at SessionModelRequest.executeTool. A decline
-            // WITH feedback (CorrectedError) intentionally stays typed so the leaf can turn
-            // it into ToolFailure and the model continues.
             Effect.catchTag("PermissionV2.DeclinedError", (error) => Effect.die(error)),
             Effect.ensuring(
               Effect.sync(() => {

packages/core/src/plugin.ts

@@ -14,7 +14,6 @@ import { Integration } from "./integration"
 import { Location } from "./location"
 import { PluginHost } from "./plugin/host"
 import { PluginRuntime } from "./plugin/runtime"
-import { WebSearch } from "./websearch"
 import { Reference } from "./reference"
 import { SkillV2 } from "./skill"
 import { State } from "./state"
@@ -159,6 +158,5 @@ export const node = makeLocationNode({
     ToolHooks.node,
     PluginHooks.node,
     PluginRuntime.node,
-    WebSearch.node,
   ],
 })

packages/core/src/plugin/host.ts

@@ -1,8 +1,6 @@
 export * as PluginHost from "./host"
 
-import { Plugin } from "@opencode-ai/plugin/v2/effect"
-import type { IntegrationMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
-import type { CredentialOAuth } from "@opencode-ai/sdk/v2/types"
+import type { Plugin } from "@opencode-ai/plugin/v2/effect"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { App } from "../app"
 import { Effect, Schema, Stream } from "effect"
@@ -25,7 +23,6 @@ import { Tool } from "../tool/tool"
 import { Tools } from "../tool/tools"
 import { ToolHooks } from "../tool/hooks"
 import { WorkspaceV2 } from "../workspace"
-import { WebSearch } from "../websearch"
 import { PluginHooks } from "./hooks"
 
 const mutable = <T>(value: T) => value as DeepMutable<T>
@@ -41,7 +38,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
   const reference = yield* Reference.Service
   const skill = yield* SkillV2.Service
   const tools = yield* Tools.Service
-  const websearch = yield* WebSearch.Service
   const toolHooks = yield* ToolHooks.Service
   const hooks = yield* PluginHooks.Service
   const runtime = yield* PluginRuntime.Service
@@ -251,7 +247,79 @@ 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) => draft.method.update(methodImplementation(input)),
+              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
+                }
+                if (input.method.type === "command") {
+                  draft.method.update({
+                    integrationID: Integration.ID.make(input.integrationID),
+                    method: Schema.decodeUnknownSync(Integration.CommandMethod)(input.method),
+                  })
+                  return
+                }
+                draft.method.update({
+                  integrationID: Integration.ID.make(input.integrationID),
+                  method: { type: "key", label: input.method.label },
+                })
+              },
               remove: (id, method) =>
                 draft.method.remove(Integration.ID.make(id), Schema.decodeUnknownSync(Integration.Method)(method)),
             },
@@ -362,32 +430,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
         })
       },
     },
-    websearch: {
-      providers: () => response(websearch.providers()),
-      query: (input) =>
-        response(
-          websearch.query({
-            query: input.query,
-            providerID: input.providerID === undefined ? undefined : WebSearch.ID.make(input.providerID),
-          }),
-        ),
-      reload: websearch.reload,
-      transform: (callback) =>
-        websearch.transform((draft) => {
-          callback({
-            add: (definition) =>
-              draft.add({
-                id: WebSearch.ID.make(definition.id),
-                name: definition.name,
-                execute: definition.execute,
-              }),
-            default: {
-              get: draft.default.get,
-              set: (providerID) => draft.default.set(WebSearch.ID.make(providerID)),
-            },
-          })
-        }),
-    },
     session: {
       hook: (name, callback) => hooks.register("session", name, callback),
       create: (input) =>
@@ -407,50 +449,3 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
     },
   } satisfies Plugin.Context
 })
-
-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 },
-    }
-  }
-  if (input.method.type === "command") {
-    return {
-      integrationID: Integration.ID.make(input.integrationID),
-      method: Schema.decodeUnknownSync(Integration.CommandMethod)(input.method),
-    }
-  }
-  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

@@ -13,7 +13,6 @@ import { ConfigProviderPlugin } from "../config/plugin/provider"
 import { ConfigPolicyPlugin } from "../config/plugin/policy"
 import { ConfigReferencePlugin } from "../config/plugin/reference"
 import { ConfigSkillPlugin } from "../config/plugin/skill"
-import { ConfigWebSearchPlugin } from "../config/plugin/websearch"
 import { EventV2 } from "../event"
 import { FileMutation } from "../file-mutation"
 import { Form } from "../form"
@@ -22,14 +21,12 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Image } from "../image"
 import { Integration } from "../integration"
-import { KV } from "../kv"
 import { Location } from "../location"
 import { LocationMutation } from "../location-mutation"
 import { ModelsDev } from "../models-dev"
 import { Npm } from "@opencode-ai/util/npm"
 import { PermissionV2 } from "../permission"
 import { Reference } from "../reference"
-import { WebSearch } from "../websearch"
 import { Ripgrep } from "../ripgrep"
 import { SessionInstructions } from "../session/instructions"
 import { Shell } from "../shell"
@@ -53,7 +50,6 @@ 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 { SystemPromptPlugin } from "./system-prompt"
@@ -74,7 +70,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const http = yield* HttpClient.HttpClient
   const image = yield* Image.Service
   const integration = yield* Integration.Service
-  const kv = yield* KV.Service
   const location = yield* Location.Service
   const locationMutation = yield* LocationMutation.Service
   const models = yield* ModelsDev.Service
@@ -84,12 +79,12 @@ 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 shell = yield* Shell.Service
   const skill = yield* SkillV2.Service
   const tools = yield* Tools.Service
+  const websearch = yield* WebSearchTool.ConfigService
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
     Context.make(AgentV2.Service, agent),
@@ -104,7 +99,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
     Context.make(HttpClient.HttpClient, http),
     Context.make(Image.Service, image),
     Context.make(Integration.Service, integration),
-    Context.make(KV.Service, kv),
     Context.make(Location.Service, location),
     Context.make(LocationMutation.Service, locationMutation),
     Context.make(ModelsDev.Service, models),
@@ -114,12 +108,12 @@ 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(Shell.Service, shell),
     Context.make(SkillV2.Service, skill),
     Context.make(Tools.Service, tools),
+    Context.make(WebSearchTool.ConfigService, websearch),
     Context.make(WellKnown.Service, wellknown),
   )
 })
@@ -138,7 +132,6 @@ const pre = [
   ...SystemPromptPlugin.Plugins,
   ModelsDevPlugin,
   ...ProviderPlugins,
-  ...WebSearchPlugins,
   PatchTool.Plugin,
   EditTool.Plugin,
   GlobTool.Plugin,
@@ -160,7 +153,6 @@ const post = [
   ConfigCommandPlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
-  ConfigWebSearchPlugin.Plugin,
   VariantPlugin.Plugin,
   ConfigPolicyPlugin.Plugin,
 ] as const satisfies readonly InternalPlugin[]

packages/core/src/plugin/promise.ts

@@ -12,7 +12,6 @@ import { AbsolutePath } from "@opencode-ai/schema/schema"
 import { Session } from "@opencode-ai/schema/session"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { Workspace } from "@opencode-ai/schema/workspace"
-import { WebSearch } from "@opencode-ai/schema/websearch"
 import { DateTime, Effect, Scope, Stream } from "effect"
 import { Tool } from "../tool/tool"
 
@@ -198,31 +197,6 @@ export function fromPromise(plugin: Plugin) {
             hook: (name, callback) =>
               register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
           },
-          websearch: {
-            providers: (input) => run(host.websearch.providers(input)),
-            query: (input) =>
-              run(
-                host.websearch.query({
-                  ...input,
-                  providerID: input.providerID === undefined ? undefined : WebSearch.ID.make(input.providerID),
-                }),
-              ),
-            reload: () => run(host.websearch.reload()),
-            transform: (callback) =>
-              register(
-                host.websearch.transform((draft) => {
-                  callback({
-                    add: (definition) =>
-                      draft.add({
-                        id: definition.id,
-                        name: definition.name,
-                        execute: (input) => attempt((signal) => definition.execute(input, { signal })),
-                      }),
-                    default: draft.default,
-                  })
-                }),
-              ),
-          },
           session: {
             hook: (name, callback) =>
               register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
@@ -296,10 +270,6 @@ export function fromPromise(plugin: Plugin) {
   })
 }
 
-function attempt<A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) {
-  return Effect.tryPromise({ try: evaluate, catch: (cause) => cause })
-}
-
 function model(input: { readonly id: string; readonly providerID: string; readonly variant?: string }) {
   return Model.Ref.make({
     id: Model.ID.make(input.id),

packages/core/src/plugin/skill/opencode.md

@@ -4,7 +4,7 @@ Use this guide as the starting point for work involving OpenCode itself. It
 covers the core concepts needed to configure and customize OpenCode, extend it
 with plugins, and build integrations with the OpenCode SDK, clients, and API.
 
-Full documentation is available at <https://v2.opencode.ai/docs>. This overview is
+Full documentation is available at <https://v2.opencode.ai/>. This overview is
 only an index of core concepts. Before answering a question about a topic below,
 fetch the URL named in that section and use the full page as the source of
 truth. Follow links from that page when the question needs more detail. Fetch
@@ -16,7 +16,7 @@ documentation page.
 Always answer for OpenCode V2 unless the user explicitly asks about V1,
 legacy OpenCode, or migrating from V1.
 
-Use only <https://v2.opencode.ai/docs> documentation as the source of truth for V2.
+Use only <https://v2.opencode.ai/> documentation as the source of truth for V2.
 Do not use <https://opencode.ai/docs/>, which documents V1, and do not use
 general web search to resolve a V2 documentation question when the V2 docs or
 their `llms.txt` index cover it. The schema served from
@@ -29,7 +29,7 @@ V1 documentation and syntax may be consulted only when the user explicitly
 asks about V1 or when needed as migration input. Outputs and recommendations
 must still use V2 unless the user specifically requests a V1 result.
 
-## [Configuration](https://v2.opencode.ai/docs/config)
+## [Configuration](https://v2.opencode.ai/config)
 
 OpenCode configuration uses JSON or JSONC. Include the published schema so the
 user's editor can validate fields and provide autocomplete:
@@ -60,15 +60,15 @@ linked topic guide as the source of truth, and preserve unrelated settings when
 editing an existing file. Keep the published `$schema` URL in configuration
 examples, but do not fetch it to determine the V2 configuration shape.
 
-See the [full configuration guide](https://v2.opencode.ai/docs/config) for
+See the [full configuration guide](https://v2.opencode.ai/config) for
 every field, examples, config locations, and links to dedicated feature guides.
 
-## [V1 to V2 migration](https://v2.opencode.ai/docs/migrate-v1)
+## [V1 to V2 migration](https://v2.opencode.ai/migrate-v1)
 
 For any request to migrate OpenCode configuration, agents, commands, skills,
 plugins, integrations, or other behavior from V1 to V2, read the full
-[migration guide](https://v2.opencode.ai/docs/migrate-v1) before acting. In
-the repository, its source is `packages/www/content/docs/(Get started)/migrate-v1.mdx`.
+[migration guide](https://v2.opencode.ai/migrate-v1) before acting. In
+the repository, its source is `packages/docs/migrate-v1.mdx`.
 
 V1 config files and `.opencode/` definitions are intended to remain compatible.
 The only intentional breaking changes are the server API and plugin API. Native
@@ -76,18 +76,18 @@ V2 config uses more ergonomic shapes, but conversion is optional. When the user
 requests conversion, inspect the complete configuration, preserve behavior and
 unrelated settings, and apply only the relevant migrations from the guide. For
 plugin migrations, fetch and follow both the migration guide and the full
-[plugins guide](https://v2.opencode.ai/docs/build/plugins). If non-API V1
+[plugins guide](https://v2.opencode.ai/build/plugins). If non-API V1
 functionality fails in V2, use the `report` skill to file it as a compatibility
 bug.
 
-## [Plugins](https://v2.opencode.ai/docs/build/plugins)
+## [Plugins](https://v2.opencode.ai/build/plugins)
 
 For questions about creating, configuring, loading, publishing, or migrating
-plugins, fetch the full [plugins guide](https://v2.opencode.ai/docs/build/plugins)
+plugins, fetch the full [plugins guide](https://v2.opencode.ai/build/plugins)
 before answering. This includes questions about the Effect plugin API, hooks,
 transforms, tools, plugin context capabilities, and package entrypoints.
 
-## [Service](https://v2.opencode.ai/docs/troubleshooting#check-the-background-service)
+## [Service](https://v2.opencode.ai/troubleshooting#check-the-background-service)
 
 OpenCode uses a client-server architecture. Interfaces such as the TUI connect
 to a background OpenCode service, which owns sessions, configuration, plugins,
@@ -106,7 +106,7 @@ Check its status after restarting:
 opencode2 service status
 ```
 
-## [API](https://v2.opencode.ai/docs/api)
+## [API](https://v2.opencode.ai/api)
 
 OpenCode exposes an HTTP API from its server. The API is described by an
 OpenAPI document available from the running server at `/openapi.json`.
@@ -135,15 +135,15 @@ connected to an explicit server instead of its managed background service, use
 the same configured server and authentication context rather than constructing
 an unauthenticated request separately.
 
-See the [full API reference](https://v2.opencode.ai/docs/api) for available
+See the [full API reference](https://v2.opencode.ai/api) for available
 endpoints, parameters, request bodies, and response schemas. The
 raw [OpenAPI specification](https://v2.opencode.ai/openapi.json) is also
 available for code generation and other tooling.
 
-## [Client](https://v2.opencode.ai/docs/build/client)
+## [Client](https://v2.opencode.ai/build/client)
 
 For questions about connecting an application to OpenCode over the network,
-fetch the full [client guide](https://v2.opencode.ai/docs/build/client) before
+fetch the full [client guide](https://v2.opencode.ai/build/client) before
 answering.
 
 `@opencode-ai/client` is the generated TypeScript client for the OpenCode HTTP
@@ -154,7 +154,7 @@ exposes typed Effects, Streams, and decoded OpenCode schema values. Its
 `Service` API can discover, start, stop, and authenticate with the local
 background service from a Node application.
 
-## [Troubleshooting](https://v2.opencode.ai/docs/troubleshooting)
+## [Troubleshooting](https://v2.opencode.ai/troubleshooting)
 
 OpenCode runs a client and a background server. Start by determining whether a
 problem belongs to the client, the shared server, or one project.
@@ -174,6 +174,6 @@ problem belongs to the client, the shared server, or one project.
 - Redact API keys, authorization headers, prompts, file contents, and other
   sensitive data before sharing diagnostics.
 
-See the [full troubleshooting guide](https://v2.opencode.ai/docs/troubleshooting)
+See the [full troubleshooting guide](https://v2.opencode.ai/troubleshooting)
 for service lifecycle commands, API inspection, log locations, explicit server
 connections, issue-reporting details, and local development paths.

packages/core/src/plugin/supervisor.ts

@@ -20,7 +20,6 @@ import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Image } from "../image"
 import { Integration } from "../integration"
-import { KV } from "../kv"
 import { Location } from "../location"
 import { LocationMutation } from "../location-mutation"
 import { ModelsDev } from "../models-dev"
@@ -35,7 +34,7 @@ import { Shell } from "../shell"
 import { SkillV2 } from "../skill"
 import { ReadToolFileSystem } from "../tool/read-filesystem"
 import { ToolRegistry } from "../tool/registry"
-import { WebSearch } from "../websearch"
+import { WebSearchTool } from "../tool/websearch"
 import { WellKnown } from "../wellknown"
 import { PluginInternal } from "./internal"
 import { PluginRuntime } from "./runtime"
@@ -290,7 +289,6 @@ export const node = makeLocationNode({
     httpClient,
     Image.node,
     Integration.node,
-    KV.node,
     Location.node,
     LocationMutation.node,
     ModelsDev.node,
@@ -305,7 +303,7 @@ export const node = makeLocationNode({
     Shell.node,
     SkillV2.node,
     ToolRegistry.toolsNode,
-    WebSearch.node,
+    WebSearchTool.configNode,
     WellKnown.node,
   ],
 })

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

@@ -1,82 +0,0 @@
-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 McpInput = Schema.Struct({
-  query: Schema.String,
-  numResults: Schema.Number.pipe(Schema.optional),
-})
-
-const McpOutput = 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.transform((draft) => {
-      draft.update("exa", (integration) => (integration.name = "Exa"))
-      draft.method.update({
-        integrationID: "exa",
-        method: { type: "key", label: "API key (optional)" },
-      })
-      draft.method.update({
-        integrationID: "exa",
-        method: { type: "env", names: ["EXA_API_KEY"] },
-      })
-    })
-    yield* ctx.websearch.transform((draft) => {
-      draft.add({
-        id: "exa",
-        name: "Exa",
-        execute: (input) =>
-          Effect.gen(function* () {
-            const connection = yield* ctx.integration.connection.active("exa")
-            const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined
-            const url = new URL(endpoint)
-            if (credential?.type === "key") url.searchParams.set("exaApiKey", credential.key)
-            const result = yield* WebSearchMcp.call(
-              http,
-              url.toString(),
-              "web_search_exa",
-              { input: McpInput, output: McpOutput },
-              { query: input.query, numResults: 8 },
-            )
-            const content = result?.content.find((item) => item.text)
-            return content ? parseResults(content.text) : []
-          }),
-      })
-    })
-  }),
-})
-
-function parseResults(text: string) {
-  return text.split(/\n\n---\n\n/).flatMap((block) => {
-    const url = block.match(/^URL:\s*(.+)$/m)?.[1]?.trim()
-    if (!url) return []
-    const title = block.match(/^Title:\s*(.+)$/m)?.[1]?.trim()
-    const publishedText = block.match(/^Published:\s*(.+)$/m)?.[1]?.trim()
-    const published = publishedText && publishedText !== "N/A" ? Date.parse(publishedText) : undefined
-    const content = block.match(/^(?:Highlights|Text):\s*\n?([\s\S]*)$/m)?.[1]?.trim()
-    return [
-      {
-        url,
-        ...(title && title !== "N/A" ? { title } : {}),
-        ...(content ? { content } : {}),
-        time: { ...(published !== undefined && Number.isFinite(published) ? { published } : {}) },
-      },
-    ]
-  })
-}

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

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

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

@@ -1,68 +0,0 @@
-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
-    }
-  })
-}
-
-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(
-        Schema.Struct({
-          jsonrpc: Schema.Literal("2.0"),
-          id: Schema.Literal(1),
-          method: Schema.Literal("tools/call"),
-          params: Schema.Struct({ name: Schema.String, arguments: 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

@@ -1,103 +0,0 @@
-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 { App } from "../../app"
-import { WebSearchMcp } from "./mcp"
-
-export const endpoint = "https://search.parallel.ai/mcp"
-
-const McpInput = Schema.Struct({
-  objective: Schema.String,
-  search_queries: Schema.Array(Schema.String),
-  model_name: Schema.String.check(Schema.isMaxLength(100)).pipe(Schema.optional),
-})
-
-const SearchResponse = 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 McpOutput = Schema.Struct({
-  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String })),
-  structuredContent: SearchResponse,
-})
-
-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.transform((draft) => {
-      draft.update("parallel", (integration) => (integration.name = "Parallel"))
-      draft.method.update({
-        integrationID: "parallel",
-        method: { type: "key", label: "API key (optional)" },
-      })
-      draft.method.update({
-        integrationID: "parallel",
-        method: { type: "env", names: ["PARALLEL_API_KEY"] },
-      })
-    })
-    yield* ctx.websearch.transform((draft) => {
-      draft.add({
-        id: "parallel",
-        name: "Parallel",
-        execute: (input) =>
-          Effect.gen(function* () {
-            const connection = yield* ctx.integration.connection.active("parallel")
-            const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined
-            const result = yield* WebSearchMcp.call(
-              http,
-              endpoint,
-              "web_search",
-              { input: McpInput, output: McpOutput },
-              {
-                objective: input.query,
-                search_queries: [input.query],
-              },
-              {
-                "User-Agent": App.useragent(ctx.app),
-                ...(credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}),
-              },
-            )
-            return (
-              result?.structuredContent.results.map((item) => {
-                const published = item.publish_date ? Date.parse(item.publish_date) : undefined
-                return {
-                  url: item.url,
-                  ...(item.title ? { title: item.title } : {}),
-                  ...(item.excerpts.length ? { content: item.excerpts.join("\n\n") } : {}),
-                  time: { ...(published !== undefined && Number.isFinite(published) ? { published } : {}) },
-                }
-              }) ?? []
-            )
-          }),
-      })
-    })
-  }),
-})

packages/core/src/session/execution/restart.ts

@@ -40,7 +40,8 @@ export const layer = Layer.effect(
               // Drain failures are already logged and durably recorded by the execution layer.
               yield* Effect.ignore(execution.resume(sessionID))
             }),
-          { concurrency: "unbounded", discard: true },
+          // Each suspension is consumed atomically right before its drain; at most four drains run at once.
+          { concurrency: 4, discard: true },
         )
       }),
     })

packages/core/src/session/message-updater.ts

@@ -319,10 +319,7 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
       "session.text.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           const match = latestText(draft)
-          if (match) {
-            match.text = event.data.text
-            match.state = castDraft(event.data.state)
-          }
+          if (match) match.text = event.data.text
         })
       },
       "session.tool.input.started": (event) => {

packages/core/src/session/model-request.ts

@@ -2,47 +2,26 @@ export * as SessionModelRequest from "./model-request"
 
 import { LLM, Message, SystemPart, type LLMRequest, type ToolContent } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Cause, Context, Effect, Layer, Result } from "effect"
+import { Context, Effect, Layer, LogLevel } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { App } from "../app"
 import { ModelV2 } from "../model"
-import { PermissionV2 } from "../permission"
 import { PluginHooks } from "../plugin/hooks"
-import { QuestionTool } from "../tool/question"
-import { ToolOutputStore } from "../tool-output-store"
 import { ToolRegistry } from "../tool/registry"
 import { SessionContext } from "./context"
 import { SessionModelHeaders } from "./model-headers"
+import { PromptCacheDiagnostics } from "./prompt-cache-diagnostics"
 import { MAX_STEPS_PROMPT } from "./runner/max-steps"
 import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message"
 
-/** Failures a prepared execution can surface: infrastructure errors plus user declines resurfaced from the defect tunnel. */
-export type ExecuteError = ToolOutputStore.Error | PermissionV2.DeclinedError | QuestionTool.CancelledError
-
-// User declines dive under the leaves' blanket `mapError` as defects (the deliberate
-// tunnel entered in PermissionV2.assert and the question tool), so a user's "no" can
-// never become model-facing tool output. They resurface as typed failures exactly once,
-// here at the seam the runner executes through.
-const declineDefect = (cause: Cause.Cause<ToolOutputStore.Error>) => {
-  const decline = cause.reasons.flatMap((reason) =>
-    Cause.isDieReason(reason) &&
-    (reason.defect instanceof PermissionV2.DeclinedError || reason.defect instanceof QuestionTool.CancelledError)
-      ? [reason.defect]
-      : [],
-  )[0]
-  return decline ? Result.succeed(decline) : Result.fail(cause)
-}
-
 interface Prepared {
   readonly request: LLMRequest
   /**
    * One request-scoped execution operation. Unknown, hook-removed, and
    * step-limit-violating calls fail individually through the same seam.
    */
-  readonly executeTool: (
-    input: ToolRegistry.ExecuteInput,
-  ) => Effect.Effect<ToolRegistry.ToolOutcome, ExecuteError>
+  readonly executeTool: ToolRegistry.ToolSet["execute"]
   /** True when this request is the final Step; violating calls are rejected and no continuation follows. */
   readonly stepLimitReached: boolean
 }
@@ -109,6 +88,7 @@ export const layer = Layer.effect(
   Effect.gen(function* () {
     const hooks = yield* PluginHooks.Service
     const app = yield* App.Metadata
+    const promptCacheSnapshots = new Map<string, PromptCacheDiagnostics.Snapshot>()
 
     const prepare = Effect.fn("SessionModelRequest.prepare")(function* (input: PrepareInput) {
       const session = input.context.session
@@ -156,7 +136,24 @@ export const layer = Layer.effect(
         tools: hookedTools,
         toolChoice: stepLimitReached ? "none" : undefined,
       })
-      const executeTool: Prepared["executeTool"] = (executeInput) => {
+      if (yield* LogLevel.isEnabled("Debug")) {
+        const current = PromptCacheDiagnostics.snapshot(request)
+        const comparison = PromptCacheDiagnostics.compare(promptCacheSnapshots.get(session.id), current)
+        promptCacheSnapshots.delete(session.id)
+        promptCacheSnapshots.set(session.id, current)
+        const oldest = promptCacheSnapshots.keys().next().value
+        if (promptCacheSnapshots.size > 100 && oldest !== undefined) promptCacheSnapshots.delete(oldest)
+        yield* Effect.logDebug("prompt cache prefix").pipe(
+          Effect.annotateLogs({
+            sessionID: session.id,
+            toolCount: current.tools.length,
+            systemParts: current.system.length,
+            messageCount: current.messages.length,
+            ...comparison,
+          }),
+        )
+      }
+      const executeTool: ToolRegistry.ToolSet["execute"] = (executeInput) => {
         if (stepLimitReached)
           return Effect.succeed({
             status: "error",
@@ -167,9 +164,7 @@ export const layer = Layer.effect(
             status: "error",
             error: { type: "tool.unknown", message: `Tool is not available for this request: ${executeInput.call.name}` },
           })
-        return toolSet
-          .execute(executeInput)
-          .pipe(Effect.catchCauseFilter(declineDefect, (decline) => Effect.fail(decline)))
+        return toolSet.execute(executeInput)
       }
       return {
         request,

packages/core/src/session/prompt-cache-diagnostics.ts

@@ -0,0 +1,95 @@
+export * as PromptCacheDiagnostics from "./prompt-cache-diagnostics"
+
+import type { LLMRequest } from "@opencode-ai/ai"
+import { Hash } from "@opencode-ai/util/hash"
+
+interface Entry {
+  readonly label: string
+  readonly hash: string
+}
+
+export interface Snapshot {
+  readonly settings: string
+  readonly tools: ReadonlyArray<Entry>
+  readonly system: ReadonlyArray<Entry>
+  readonly messages: ReadonlyArray<Entry>
+}
+
+export type Comparison =
+  | { readonly status: "initial" }
+  | { readonly status: "stable"; readonly messages: number }
+  | { readonly status: "append-only"; readonly previousMessages: number; readonly currentMessages: number }
+  | {
+      readonly status: "changed"
+      readonly component: "settings" | "tools" | "system" | "messages"
+      readonly index: number
+      readonly label: string
+    }
+
+const hash = (value: unknown) => Hash.sha256(JSON.stringify(value)).slice(0, 16)
+
+export function snapshot(request: LLMRequest): Snapshot {
+  return {
+    settings: hash({
+      route: request.model.route.id,
+      provider: request.model.provider,
+      model: request.model.id,
+      modelDefaults: request.model.defaults,
+      compatibility: request.model.compatibility,
+      routeDefaults: {
+        generation: request.model.route.defaults.generation,
+        providerOptions: request.model.route.defaults.providerOptions,
+        http: request.model.route.defaults.http,
+      },
+      generation: request.generation,
+      providerOptions: request.providerOptions,
+      http: request.http,
+      toolChoice: request.toolChoice,
+      cache: request.cache,
+    }),
+    tools: request.tools.map((tool) => ({ label: tool.name, hash: hash(tool) })),
+    system: request.system.map((part, index) => ({ label: `system[${index}]`, hash: hash(part) })),
+    messages: request.messages.map((message, index) => ({
+      label: message.id ?? `${message.role}[${index}]`,
+      hash: hash(message),
+    })),
+  }
+}
+
+export function compare(previous: Snapshot | undefined, current: Snapshot): Comparison {
+  if (!previous) return { status: "initial" }
+  if (previous.settings !== current.settings)
+    return {
+      status: "changed",
+      component: "settings",
+      index: 0,
+      label: "model settings",
+    }
+  const tools = firstChange(previous.tools, current.tools, false)
+  if (tools) return { status: "changed", component: "tools", ...tools }
+  const system = firstChange(previous.system, current.system, false)
+  if (system) return { status: "changed", component: "system", ...system }
+  const messages = firstChange(previous.messages, current.messages, true)
+  if (messages) return { status: "changed", component: "messages", ...messages }
+  if (previous.messages.length === current.messages.length)
+    return { status: "stable", messages: current.messages.length }
+  return {
+    status: "append-only",
+    previousMessages: previous.messages.length,
+    currentMessages: current.messages.length,
+  }
+}
+
+function firstChange(previous: ReadonlyArray<Entry>, current: ReadonlyArray<Entry>, allowAppend: boolean) {
+  const index = previous.findIndex((entry, index) => entry.hash !== current[index]?.hash)
+  if (index >= 0)
+    return {
+      index,
+      label: current[index]?.label ?? previous[index]?.label ?? `entry[${index}]`,
+    }
+  if (current.length === previous.length || (allowAppend && current.length > previous.length)) return
+  return {
+    index: previous.length,
+    label: current[previous.length]?.label ?? `entry[${previous.length}]`,
+  }
+}

packages/core/src/session/runner/llm.ts

@@ -1,7 +1,7 @@
 export * as SessionRunnerLLM from "./llm"
 
-import { LLMClient, LLMError, LLMEvent, isContextOverflowFailure, type ProviderErrorEvent, type ToolCall } from "@opencode-ai/ai"
-import { Cause, Data, Effect, Exit, Fiber, FiberSet, Layer, Option, Pull, Schedule, Stream } from "effect"
+import { LLMClient, LLMError, LLMEvent, isContextOverflowFailure, type ProviderErrorEvent } from "@opencode-ai/ai"
+import { Cause, Data, Effect, Exit, Fiber, FiberSet, Layer, Option, Pull, Schedule, Semaphore, Stream } from "effect"
 import { Database } from "../../database/database"
 import { EventV2 } from "../../event"
 import { PermissionV2 } from "../../permission"
@@ -18,7 +18,7 @@ import { SessionSchema } from "../schema"
 import { SessionStore } from "../store"
 import { SessionTitle } from "../title"
 import { Service } from "./index"
-import { createLLMEventPublisher, type StepRecord } from "./publish-llm-event"
+import { createLLMEventPublisher } from "./publish-llm-event"
 import { Snapshot } from "../../snapshot"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../../effect/app-node-platform"
@@ -36,53 +36,32 @@ type CallOutcome = Data.TaggedEnum<{
 const CallOutcome = Data.taggedEnum<CallOutcome>()
 
 // Declining an interactive prompt halts the drain instead of becoming model-facing tool output.
-const isDecline = (
-  error: SessionModelRequest.ExecuteError,
-): error is PermissionV2.DeclinedError | QuestionTool.CancelledError =>
-  error._tag === "PermissionV2.DeclinedError" || error._tag === "QuestionTool.CancelledError"
+const isUserDeclined = (cause: Cause.Cause<unknown>) =>
+  cause.reasons.some(
+    (reason) =>
+      Cause.isDieReason(reason) &&
+      (reason.defect instanceof PermissionV2.DeclinedError || reason.defect instanceof QuestionTool.CancelledError),
+  )
 
 /**
- * Classifies how the owned tool fibers ended. Interrupts abort the step; a user decline
- * settles its own call and then aborts the step; a defect from a tool implementation
- * becomes a failed tool call the model can read; a typed infrastructure failure must
- * fail the assistant and then the drain.
+ * Classifies how the owned tool fibers ended. Interrupts and interactive declines abort
+ * the step; a defect from a tool implementation becomes a failed tool call the model can
+ * read; a typed infrastructure failure must fail the assistant and then the drain.
  */
-const classifyToolExits = (
-  settled: Exit.Exit<Array<Exit.Exit<void, SessionModelRequest.ExecuteError>>, never>,
-  calls: ReadonlyArray<ToolCall>,
-) => {
-  // Exits align with calls by construction: one owned fiber per accepted local call.
-  const exits = settled._tag === "Success" ? settled.value : []
-  const declines = exits.flatMap((exit, index) =>
-    exit._tag === "Failure"
-      ? exit.cause.reasons.flatMap((reason) =>
-          Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : [],
-        )
-      : [],
-  )
+const classifyToolExits = (settled: Exit.Exit<Array<Exit.Exit<void, ToolOutputStore.Error>>, never>) => {
   const causes =
-    settled._tag === "Failure" ? [settled.cause] : exits.flatMap((exit) => (exit._tag === "Failure" ? [exit.cause] : []))
-  // The first non-interrupt, non-decline failure, rebuilt without decline reasons so the
-  // drain's error channel never carries a decline.
-  const failure = causes.flatMap((cause) => {
-    if (Cause.hasInterrupts(cause)) return []
-    const reasons = cause.reasons.flatMap((reason): Array<Cause.Reason<ToolOutputStore.Error>> =>
-      Cause.isFailReason(reason) ? (isDecline(reason.error) ? [] : [Cause.makeFailReason(reason.error)]) : [reason],
-    )
-    return reasons.length > 0 ? [Cause.fromReasons(reasons)] : []
-  }).at(0)
+    settled._tag === "Failure"
+      ? [settled.cause]
+      : settled.value.flatMap((exit) => (exit._tag === "Failure" ? [exit.cause] : []))
+  const failure = causes.find((cause) => !Cause.hasInterrupts(cause) && !isUserDeclined(cause))
   return {
     interrupted: causes.some(Cause.hasInterrupts),
-    declines,
+    declined: causes.some(isUserDeclined),
     failure,
     infraError: failure === undefined ? undefined : Option.getOrUndefined(Cause.findErrorOption(failure)),
   }
 }
 
-const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
-const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
-const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
-
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -224,12 +203,9 @@ const layer = Layer.effect(
         context: loaded,
         step: currentStep,
       })
-      // Every local tool call forked here is owned until it reaches one durable settlement.
-      const toolRuns: Array<{
-        readonly call: ToolCall
-        readonly fiber: Fiber.Fiber<void, SessionModelRequest.ExecuteError>
-      }> = []
-      const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
+      const toolFibers = yield* FiberSet.make<void, ToolOutputStore.Error>()
+      const ownedToolFibers: Array<Fiber.Fiber<void, ToolOutputStore.Error>> = []
+      let needsContinuation = false
       const startSnapshot = yield* snapshots.capture()
       const publisher = createLLMEventPublisher(events, {
         sessionID: session.id,
@@ -241,9 +217,15 @@ const layer = Layer.effect(
         snapshot: startSnapshot,
         assistantMessageID,
       })
-      const stepUsage = (finish: NonNullable<StepRecord["finish"]>) => ({
-        cost: SessionUsage.calculateCost(resolved.cost, finish.tokens),
-        tokens: finish.tokens,
+      const publication = Semaphore.makeUnsafe(1)
+      // Durable publishes are serialized so tool fibers and step settlement never interleave
+      // mid-event.
+      const serialized = <A, E, R>(effect: Effect.Effect<A, E, R>) => publication.withPermit(effect)
+      const publish = (event: LLMEvent) => serialized(publisher.publish(event))
+
+      const stepUsage = (settlement: NonNullable<ReturnType<typeof publisher.stepSettlement>>) => ({
+        cost: SessionUsage.calculateCost(resolved.cost, settlement.tokens),
+        tokens: settlement.tokens,
       })
 
       const captureStepEnd = Effect.fnUntraced(function* () {
@@ -257,26 +239,20 @@ const layer = Layer.effect(
         return { snapshot, files }
       })
 
-      const publishStepEnd = (finish: NonNullable<StepRecord["finish"]>) =>
+      const publishStepEnd = (settlement: NonNullable<ReturnType<typeof publisher.stepSettlement>>) =>
         Effect.gen(function* () {
           const end = yield* captureStepEnd()
-          yield* events.publish(SessionEvent.Step.Ended, {
-            sessionID: session.id,
-            assistantMessageID: yield* publisher.startAssistant(),
-            finish: finish.finish,
-            ...stepUsage(finish),
-            ...end,
-          })
+          yield* serialized(
+            events.publish(SessionEvent.Step.Ended, {
+              sessionID: session.id,
+              assistantMessageID: yield* publisher.startAssistant(),
+              finish: settlement.finish,
+              ...stepUsage(settlement),
+              ...end,
+            }),
+          )
         })
 
-      // Concurrent writers, no lock: the provider loop and each tool fiber publish
-      // durable events unserialized. This is safe because every publisher method commits
-      // its state marks synchronously before its first await (see publish-llm-event.ts),
-      // every required event order is per-source (each source is one sequential fiber),
-      // and a fiber's events are causally after its own Tool.Called: the fork happens
-      // below that publish. Cross-source order is unconstrained; either interleaving is
-      // a truthful history of concurrent work.
-      //
       // The stream is defined here but runs inside the settlement mask below: publish each
       // event durably, fork one fiber per local tool call, and hold back a virgin
       // context-overflow provider error so settlement may recover it via compaction.
@@ -286,40 +262,43 @@ const layer = Layer.effect(
           Effect.gen(function* () {
             if (overflowFailure || publisher.hasProviderError()) return
             if (LLMEvent.is.providerError(event)) {
-              if (isContextOverflowFailure(event) && !publisher.record().outputStarted) {
+              if (isContextOverflowFailure(event) && !publisher.hasRetryEvidence()) {
                 overflowFailure = event
                 return
               }
             }
-            yield* publisher.publish(event)
+            yield* publish(event)
+            if (LLMEvent.is.toolInputError(event)) {
+              if (!prepared.stepLimitReached) needsContinuation = true
+              return
+            }
             if (event.type !== "tool-call" || event.providerExecuted) return
+            // Unavailable calls fail individually through the same execution seam;
+            // continuation depends only on remaining Step allowance.
+            if (!prepared.stepLimitReached) needsContinuation = true
             const assistantMessageID = yield* publisher.assistantMessageID(event.id)
-            toolRuns.push({
-              call: event,
-              fiber: yield* Effect.uninterruptibleMask((restore) =>
+            ownedToolFibers.push(
+              yield* Effect.uninterruptibleMask((restore) =>
                 restore(
                   prepared.executeTool({
                     sessionID: session.id,
                     agent: agent.id,
                     messageID: assistantMessageID,
                     call: event,
-                    // Progress is ephemeral, not durable history: nothing to order.
-                    progress: (update) => publisher.progress(event.id, update),
+                    progress: (update) => serialized(publisher.progress(event.id, update)),
                   }),
                 ).pipe(
-                  // The fiber owns its call: it publishes its own completion, masked so a
-                  // finished execution always reaches its durable settlement.
-                  Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
+                  Effect.flatMap((execution) => serialized(publisher.toolExecution(event.id, event.name, execution))),
                 ),
-              ).pipe(Effect.forkScoped),
-            })
+              ).pipe(FiberSet.run(toolFibers)),
+            )
           }),
         ),
-        Effect.ensuring(publisher.flush()),
+        Effect.ensuring(serialized(publisher.flush())),
       )
 
-      // Settle: only the stream and the fiber joins are interruptible (restore); every
-      // other line is protected so a started call always reaches one durable outcome.
+      // Settle: only the stream itself is interruptible (restore); every line after it is
+      // protected so a started call always reaches one durable outcome.
       return yield* Effect.uninterruptibleMask((restore) =>
         Effect.gen(function* () {
           const stream = yield* restore(providerStream).pipe(Effect.exit)
@@ -328,103 +307,108 @@ const layer = Layer.effect(
           // away non-interrupt failures, so both interrupt checks stay Cause-based.
           const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
 
-          // Join every owned tool run first: await all exits, not just the first failure.
-          // Afterwards no fiber is alive, settlement is the only writer, and the record
-          // is final. A failed join means the waiting itself was interrupted, so the runs
-          // we abandoned are interrupted before settlement closes them out.
-          if (streamInterrupted) yield* interruptTools
-          const joined = yield* restore(
-            Effect.forEach(toolRuns, (run) => Fiber.await(run.fiber), { concurrency: "unbounded" }),
-          ).pipe(Effect.exit)
-          if (joined._tag === "Failure") yield* interruptTools
-          const tools = classifyToolExits(
-            joined,
-            toolRuns.map((run) => run.call),
-          )
-
           // A context overflow before any assistant output is recoverable: compact and
           // restart the step instead of surfacing the provider error.
           if (
             recoverOverflow &&
-            !publisher.record().outputStarted &&
+            !publisher.hasRetryEvidence() &&
             isContextOverflowFailure(overflowFailure ?? streamFailure) &&
             (yield* restore(compaction.compact(compactionInput))).status === "completed"
           )
             return CallOutcome.Restart({ step: currentStep, recoveredOverflow: true })
 
-          // An unrecovered held-back overflow becomes the step's durable provider error.
-          if (overflowFailure) yield* publisher.publish(overflowFailure)
-          // A thrown LLM failure not already recorded as the provider error either
-          // escapes as a scheduled retry or fails the assistant durably.
+          // An unrecovered held-back overflow becomes the step's durable provider error. A
+          // thrown LLM failure records the assistant failure unless a provider error was
+          // already recorded from the stream. Terminal publication waits for owned tools.
+          if (overflowFailure) yield* publish(overflowFailure)
           const llmFailure = streamFailure instanceof LLMError ? streamFailure : undefined
-          const llmError = llmFailure && !publisher.record().providerFailed ? toSessionError(llmFailure) : undefined
-          if (llmFailure && llmError && SessionRunnerRetry.isRetryable(llmFailure) && !publisher.record().outputStarted) {
-            // RetryScheduled and Step.Failed fold onto an existing assistant message, so
-            // Step.Started must be durable before the failure escapes.
-            yield* publisher.startAssistant()
-            return yield* new SessionRunnerRetry.RetryableFailure({
-              cause: llmFailure,
-              error: llmError,
-              step: currentStep,
-            })
+          if (llmFailure && !publisher.hasProviderError()) {
+            const error = toSessionError(llmFailure)
+            if (SessionRunnerRetry.isRetryable(llmFailure) && !publisher.hasRetryEvidence()) {
+              // RetryScheduled and Step.Failed fold onto an existing assistant message, so
+              // Step.Started must be durable before the failure escapes.
+              yield* serialized(publisher.startAssistant())
+              return yield* new SessionRunnerRetry.RetryableFailure({
+                cause: llmFailure,
+                error,
+                step: currentStep,
+              })
+            }
+            yield* serialized(publisher.failAssistant(error))
           }
-          if (llmError) yield* publisher.failAssistant(llmError)
+          // Provider error events only arrive from the stream, so the flag is final here.
+          const providerFailed = publisher.hasProviderError()
 
-          // Close every unsettled call with the reason it could not settle truthfully,
-          // and fail the assistant when the step itself cannot complete. A declined call
-          // settles with its own reason before the generic sweeps.
-          for (const decline of tools.declines)
-            yield* publisher.failTool(decline.call.id, {
-              type: "aborted",
-              message:
-                decline.reason._tag === "QuestionTool.CancelledError"
-                  ? decline.reason.message
-                  : "The user declined this tool call",
-            })
-          if (tools.declines.length > 0 || streamInterrupted || tools.interrupted) {
-            yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
-            yield* publisher.failAssistant(STEP_INTERRUPTED)
+          // Settle every owned tool fiber. FiberSet.join returns on the first failure, so retain
+          // the individual fibers and await all exits before publishing the terminal step event.
+          if (streamInterrupted) yield* FiberSet.clear(toolFibers)
+          const settled = yield* restore(
+            Effect.forEach(ownedToolFibers, Fiber.await, { concurrency: "unbounded" }),
+          ).pipe(Effect.exit)
+          if (settled._tag === "Failure") yield* FiberSet.clear(toolFibers)
+          const tools = classifyToolExits(settled)
+
+          if (tools.declined || streamInterrupted || tools.interrupted) {
+            yield* serialized(publisher.failUnsettledTools({ type: "aborted", message: "Tool execution interrupted" }))
+            yield* serialized(publisher.failAssistant({ type: "aborted", message: "Step interrupted" }))
           }
           if (tools.failure !== undefined) {
             const error = toSessionError(tools.infraError ?? Cause.squash(tools.failure))
-            yield* publisher.failUnsettledTools(error)
-            if (tools.infraError !== undefined) yield* publisher.failAssistant(error)
-          }
-          // Local calls have joined, so the remaining sweeps only close hosted calls the
-          // provider promised but never resolved.
-          if (publisher.record().providerFailed) yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
-          if (llmError) yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
-          // A clean stream that still left hosted calls unresolved fails the step itself.
-          if (stream._tag === "Success" && !publisher.record().providerFailed) {
-            const hostedResultMissing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
-            if (hostedResultMissing && !publisher.record().finish) yield* publisher.failAssistant(RESULT_MISSING)
+            yield* serialized(publisher.failUnsettledTools(error))
+            if (tools.infraError !== undefined) yield* serialized(publisher.failAssistant(error))
           }
 
-          // One terminal event: Step.Ended on a clean finish, Step.Failed otherwise.
-          const record = publisher.record()
-          if (record.finish && !record.failure) yield* publishStepEnd(record.finish)
-          if (record.failure) {
+          // Fail unresolved calls before the terminal step event. Local calls have joined, so
+          // these sweeps only close calls that could not produce a truthful settlement.
+          if (providerFailed)
+            yield* serialized(publisher.failUnsettledTools({ type: "aborted", message: "Tool execution interrupted" }))
+          if (llmFailure && !providerFailed)
+            yield* serialized(
+              publisher.failUnsettledTools(
+                {
+                  type: "tool.result-missing",
+                  message: "Provider did not return a tool result",
+                },
+                true,
+              ),
+            )
+          const hostedResultMissing =
+            stream._tag === "Success" && !providerFailed
+              ? yield* serialized(
+                  publisher.failUnsettledTools(
+                    { type: "tool.result-missing", message: "Provider did not return a tool result" },
+                    true,
+                  ),
+                )
+              : false
+          if (hostedResultMissing && !publisher.stepSettlement())
+            yield* serialized(
+              publisher.failAssistant({
+                type: "tool.result-missing",
+                message: "Provider did not return a tool result",
+              }),
+            )
+
+          const stepFailure = publisher.stepFailure()
+          const stepSettlement = publisher.stepSettlement()
+          if (stepSettlement && !stepFailure) yield* publishStepEnd(stepSettlement)
+          if (stepFailure) {
             const end = yield* captureStepEnd()
-            yield* publisher.publishStepFailure({
-              ...(record.finish ? stepUsage(record.finish) : {}),
-              ...end,
-            })
+            yield* serialized(
+              publisher.publishStepFailure({
+                ...(stepSettlement ? stepUsage(stepSettlement) : {}),
+                ...end,
+              }),
+            )
           }
 
           if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
-          if (tools.declines.length > 0) return yield* Effect.interrupt
+          if (tools.declined) return yield* Effect.interrupt
           if ((tools.interrupted || tools.infraError !== undefined) && tools.failure)
             return yield* Effect.failCause(tools.failure)
-          if (tools.interrupted && joined._tag === "Failure") return yield* Effect.failCause(joined.cause)
-          if (record.failure) return yield* new StepFailedError({ error: record.failure })
-          return CallOutcome.Completed({
-            // A local call or malformed tool input requires another model step, unless
-            // this step already exhausted the agent's allowance.
-            needsContinuation:
-              !prepared.stepLimitReached &&
-              record.calls.some((call) => !call.providerExecuted && (call.called || call.settled)),
-            step: currentStep,
-          })
+          if (tools.interrupted && settled._tag === "Failure") return yield* Effect.failCause(settled.cause)
+          if (stepFailure) return yield* new StepFailedError({ error: stepFailure })
+          return CallOutcome.Completed({ needsContinuation, step: currentStep })
         }),
       )
     }, Effect.scoped)

packages/core/src/session/runner/publish-llm-event.ts

@@ -23,30 +23,9 @@ type Input = {
   readonly assistantMessageID: SessionMessage.ID
 }
 
-const asRecord = (value: unknown): Record<string, unknown> =>
+const record = (value: unknown): Record<string, unknown> =>
   typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record<string, unknown>) : { value }
 
-/** Immutable fold of the durable facts a step's writer has recorded so far. */
-export interface StepRecord {
-  /** The model produced visible output this attempt, which bars transparent retries and overflow recovery. */
-  readonly outputStarted: boolean
-  readonly providerFailed: boolean
-  /** The step's recorded assistant failure, if any. */
-  readonly failure?: SessionError.Error
-  /** Present once the provider finished the step normally. */
-  readonly finish?: {
-    readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]["normalized"]
-    readonly tokens: ReturnType<typeof SessionUsage.tokens>
-  }
-  readonly calls: ReadonlyArray<{
-    readonly id: string
-    readonly name: string
-    readonly called: boolean
-    readonly settled: boolean
-    readonly providerExecuted: boolean
-  }>
-}
-
 /** Derives canonical model content from a provider-hosted tool result. */
 const hostedContent = (result: ToolResultValue): Tool.NonEmptyContent => {
   if (result.type === "content") {
@@ -56,17 +35,7 @@ const hostedContent = (result: ToolResultValue): Tool.NonEmptyContent => {
   return [{ type: "text", text: Tool.stringify(result.value) }]
 }
 
-/**
- * Persist one step without executing tools or starting a continuation step.
- *
- * Concurrency invariant: the provider loop and each owned tool fiber call these methods
- * concurrently without a lock. Two rules keep that safe, and every method must preserve
- * them. (1) Commit state marks synchronously before the first await: never a yield
- * between a check (`tool.settled`, `stepStarted`, ...) and its mark, so check-and-mark
- * stays atomic under cooperative scheduling. (2) Never require a cross-source event
- * order: each publishing fiber is sequential, so per-source order holds by construction,
- * and consumers fold by callID/ordinal rather than global position.
- */
+/** Persist one step without executing tools or starting a continuation step. */
 export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish">, input: Input) => {
   const tools = new Map<
     string,
@@ -85,9 +54,14 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
   let stepStarted = false
   let stepFailed = false
   let providerFailed = false
-  let outputStarted = false
+  let retryEvidence = false
   let stepFailure: SessionError.Error | undefined
-  let stepSettlement: StepRecord["finish"]
+  let stepSettlement:
+    | {
+        readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]["normalized"]
+        readonly tokens: ReturnType<typeof SessionUsage.tokens>
+      }
+    | undefined
 
   const startAssistant = Effect.fnUntraced(function* () {
     if (stepStarted) return assistantMessageID
@@ -149,14 +123,13 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
 
   const text = fragments(
     "text",
-    (_textID, value, ordinal, state) =>
+    (_textID, value, ordinal) =>
       Effect.gen(function* () {
         yield* events.publish(SessionEvent.Text.Ended, {
           sessionID: input.sessionID,
           assistantMessageID: yield* currentAssistantMessageID(),
           ordinal,
           text: value,
-          state,
         })
       }),
     true,
@@ -259,27 +232,21 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
     yield* flushFragments()
   })
 
-  const failTool = Effect.fnUntraced(function* (callID: string, error: SessionError.Error) {
-    const tool = tools.get(callID)
-    if (!tool || tool.settled) return false
-    tool.settled = true
-    yield* events.publish(SessionEvent.Tool.Failed, {
-      sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
-      callID,
-      error,
-      ...failureSnapshot(tool),
-      executed: tool.providerExecuted,
-    })
-    return true
-  })
-
   const failTools = Effect.fnUntraced(function* (error: SessionError.Error, mode: "all" | "hosted" | "uncalled") {
     let failed = false
     for (const [callID, tool] of tools) {
       if (tool.settled || (mode === "hosted" && !tool.providerExecuted) || (mode === "uncalled" && tool.called))
         continue
-      failed = (yield* failTool(callID, error)) || failed
+      tool.settled = true
+      failed = true
+      yield* events.publish(SessionEvent.Tool.Failed, {
+        sessionID: input.sessionID,
+        assistantMessageID: tool.assistantMessageID,
+        callID,
+        error,
+        ...failureSnapshot(tool),
+        executed: tool.providerExecuted,
+      })
     }
     return failed
   })
@@ -310,9 +277,9 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
 
   const failUnsettledTools = Effect.fn("SessionRunner.failUnsettledTools")(function* (
     error: SessionError.Error,
-    scope: "hosted" | "all" = "all",
+    hostedOnly = false,
   ) {
-    return yield* failTools(error, scope)
+    return yield* failTools(error, hostedOnly ? "hosted" : "all")
   })
 
   const assistantMessageIDForTool = (callID: string) => {
@@ -326,8 +293,8 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
         yield* startAssistant()
         return
       case "text-start":
-        outputStarted = true
-        const startedTextOrdinal = yield* text.start(event.id, providerState(event.providerMetadata))
+        retryEvidence = true
+        const startedTextOrdinal = yield* text.start(event.id)
         yield* events.publish(SessionEvent.Text.Started, {
           sessionID: input.sessionID,
           assistantMessageID: yield* startAssistant(),
@@ -335,7 +302,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
         })
         return
       case "text-delta":
-        const deltaTextOrdinal = yield* text.append(event.id, event.text, providerState(event.providerMetadata))
+        const deltaTextOrdinal = yield* text.append(event.id, event.text)
         yield* events.publish(SessionEvent.Text.Delta, {
           sessionID: input.sessionID,
           assistantMessageID: yield* currentAssistantMessageID(),
@@ -344,10 +311,10 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
         })
         return
       case "text-end":
-        yield* text.end(event.id, providerState(event.providerMetadata))
+        yield* text.end(event.id)
         return
       case "reasoning-start":
-        outputStarted = true
+        retryEvidence = true
         const startedReasoningOrdinal = yield* reasoning.start(event.id, providerState(event.providerMetadata))
         yield* events.publish(SessionEvent.Reasoning.Started, {
           sessionID: input.sessionID,
@@ -373,7 +340,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
         yield* reasoning.end(event.id, providerState(event.providerMetadata))
         return
       case "tool-input-start":
-        outputStarted = true
+        retryEvidence = true
         yield* startToolInput(event)
         return
       case "tool-input-delta": {
@@ -395,11 +362,11 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
         yield* endToolInput(event)
         return
       case "tool-input-error":
-        outputStarted = true
+        retryEvidence = true
         yield* failMalformedToolInput(event)
         return
       case "tool-call": {
-        outputStarted = true
+        retryEvidence = true
         if (!tools.has(event.id)) yield* startToolInput(event)
         const tool = tools.get(event.id)!
         if (toolInput.has(event.id)) yield* endToolInput(event)
@@ -412,7 +379,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
           sessionID: input.sessionID,
           assistantMessageID: tool.assistantMessageID,
           callID: event.id,
-          input: asRecord(event.input),
+          input: record(event.input),
           executed: tool.providerExecuted,
           state: providerState(event.providerMetadata),
         })
@@ -558,24 +525,12 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
     toolExecution,
     flush,
     failAssistant,
-    failTool,
     publishStepFailure,
     failUnsettledTools,
     hasProviderError: () => providerFailed,
-    /** Immutable snapshot of everything recorded for this step so far. */
-    record: (): StepRecord => ({
-      outputStarted,
-      providerFailed,
-      failure: stepFailure,
-      finish: stepSettlement,
-      calls: Array.from(tools, ([id, tool]) => ({
-        id,
-        name: tool.name,
-        called: tool.called,
-        settled: tool.settled,
-        providerExecuted: tool.providerExecuted,
-      })),
-    }),
+    hasRetryEvidence: () => retryEvidence,
+    stepFailure: () => stepFailure,
+    stepSettlement: () => stepSettlement,
     startAssistant,
     assistantMessageID: assistantMessageIDForTool,
   }

packages/core/src/session/runner/to-llm-message.ts

@@ -113,14 +113,7 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
   const sameModel = sameProvider && String(message.model.id) === String(model.id)
   const reuseProviderMetadata = sameModel && message.error === undefined
   const content = message.content.flatMap((item): ContentPart[] => {
-    if (item.type === "text")
-      return [
-        {
-          type: "text",
-          text: item.text,
-          providerMetadata: sameProvider ? providerMetadata(providerMetadataKey, item.state) : undefined,
-        },
-      ]
+    if (item.type === "text") return [{ type: "text", text: item.text }]
     if (item.type === "reasoning")
       return reuseProviderMetadata
         ? [

packages/core/src/tool/AGENTS.md

@@ -24,7 +24,7 @@ const source = {
 }
 ```
 
-Leaves own resolution, permission, and side-effect ordering. Translate only expected typed errors into `ToolFailure`; do not use `catchCause`, because interruption and defects must survive. User declines from `PermissionV2.assert` and question dismissals travel as defects beneath leaf `mapError` blankets and resurface as typed failures at `SessionModelRequest.executeTool`; leaves must never catch or convert them. A decline with feedback (`PermissionV2.CorrectedError`) stays typed so the leaf converts it into `ToolFailure` and the model continues.
+Leaves own resolution, permission, and side-effect ordering. Translate only expected typed errors into `ToolFailure`; do not use `catchCause`, because interruption and defects must survive.
 
 ## Registration
 

packages/core/src/tool/execute.ts

@@ -3,7 +3,7 @@ export type { Registration } from "./tool"
 
 import { CodeMode, Tool, toolError } from "@opencode-ai/codemode"
 import type { ToolContent } from "@opencode-ai/ai"
-import { Effect, Ref, Schema, Semaphore } from "effect"
+import { Effect, Ref, Schema } from "effect"
 import { execute, make, toLLMDefinition, type Content, type Metadata, type Registration } from "./tool"
 
 const ExecuteFile = Schema.Struct({
@@ -34,12 +34,10 @@ type CollectedFiles = {
 
 // Invariant model-facing guidance; the changing tool catalog is delivered through Instructions.
 const description = [
-  "Run JavaScript to orchestrate tool calls and compose their results through `{ code }` in a confined Code Mode runtime.",
-  "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
-  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
-  'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
-  "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
-  "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`.",
+  "Run JavaScript in a confined Code Mode runtime through { code }.",
+  "Call Code Mode tools through `tools` using the exact paths and signatures from the instructions.",
+  "Use `search({ query })` to discover exact signatures when needed.",
+  "Await important calls and use `Promise.all` for independent calls.",
 ].join("\n")
 
 export const create = (registrations: ReadonlyMap<string, Registration>) => {
@@ -52,11 +50,12 @@ export const create = (registrations: ReadonlyMap<string, Registration>) => {
         const callIndex = yield* Ref.make(0)
         const files = yield* Ref.make<Array<CollectedFiles>>([])
         const calls = yield* Ref.make<Array<ExecuteCall>>([])
-        const lock = Semaphore.makeUnsafe(1)
-        const updateCalls = (update: (items: Array<ExecuteCall>) => Array<ExecuteCall>) =>
-          lock.withPermit(
-            Ref.updateAndGet(calls, update).pipe(Effect.flatMap((toolCalls) => context.progress({ toolCalls }))),
-          )
+        // TODO: Publish live call-list updates once V2 has a generic tool progress API.
+        const finalCalls = Ref.get(calls).pipe(
+          Effect.map((items) =>
+            items.map((call) => (call.status === "running" ? { ...call, status: "error" as const } : call)),
+          ),
+        )
         const result = yield* runtime(
           registrations,
           (name, registration, input) =>
@@ -67,7 +66,7 @@ export const create = (registrations: ReadonlyMap<string, Registration>) => {
                 agent: context.agent,
                 messageID: context.messageID,
                 callID: context.callID,
-                progress: () => Effect.void,
+                progress: context.progress,
               }).pipe(Effect.mapError((failure) => toolError(failure.message, failure)))
               const outputFileParts = outputFiles(executed.content)
               if (outputFileParts.length > 0)
@@ -75,28 +74,26 @@ export const create = (registrations: ReadonlyMap<string, Registration>) => {
               return executed.output
             }),
           {
-            onToolCallStart: ({ index, name, input }) => {
-              const shown = displayInput(input)
-              return updateCalls((items) => {
+            onToolCallStart: ({ index, name, input }) =>
+              Effect.gen(function* () {
+                const shown = displayInput(input)
+                yield* Ref.update(calls, (items) => {
+                  const next = [...items]
+                  next[index] = { tool: name, status: "running", ...(shown ? { input: shown } : {}) }
+                  return next
+                })
+              }),
+            onToolCallEnd: ({ index, outcome }) =>
+              Ref.update(calls, (items) => {
+                const current = items[index]
+                if (!current) return items
                 const next = [...items]
-                next[index] = { tool: name, status: "running", ...(shown ? { input: shown } : {}) }
+                next[index] = { ...current, status: outcome === "success" ? "completed" : "error" }
                 return next
-              })
-            },
-            onToolCallEnd: ({ index, name, input, outcome }) => {
-              const shown = displayInput(input)
-              return updateCalls((items) => {
-                const next = [...items]
-                next[index] = {
-                  ...(items[index] ?? { tool: name, ...(shown ? { input: shown } : {}) }),
-                  status: outcome === "success" ? "completed" : "error",
-                }
-                return next
-              })
-            },
+              }),
           },
         ).execute(code)
-        const toolCalls = yield* Ref.get(calls)
+        const toolCalls = yield* finalCalls
         const collected = (yield* Ref.get(files))
           .toSorted((left, right) => left.index - right.index)
           .flatMap((item) => item.files)

packages/core/src/tool/glob.ts

@@ -7,7 +7,6 @@ import path from "path"
 import { FileSystem } from "../filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../location"
-import { LocationMutation } from "../location-mutation"
 import { Ripgrep } from "../ripgrep"
 import { RelativePath } from "../schema"
 import { PermissionV2 } from "../permission"
@@ -18,10 +17,10 @@ export const name = "glob"
 export const Input = Schema.Struct({
   pattern: FileSystem.GlobInput.fields.pattern.annotate({ description: "Glob pattern to match files against" }),
   path: RelativePath.pipe(Schema.optional).annotate({
-    description: "Directory to search. Defaults to the current working directory.",
+    description: "Relative directory to search. Defaults to the active Location.",
   }),
   limit: FileSystem.GlobInput.fields.limit.annotate({
-    description: `Maximum number of matching files to return (default: ${FileSystem.DEFAULT_SEARCH_LIMIT})`,
+    description: `Maximum results to return (default: ${FileSystem.DEFAULT_SEARCH_LIMIT})`,
   }),
 })
 
@@ -46,7 +45,6 @@ export const Plugin = {
     const fs = yield* FSUtil.Service
     const ripgrep = yield* Ripgrep.Service
     const location = yield* Location.Service
-    const mutation = yield* LocationMutation.Service
     const permission = yield* PermissionV2.Service
 
     yield* ctx.tool
@@ -55,51 +53,36 @@ export const Plugin = {
           name,
           Tool.make({
             description:
-              'Search file paths using a glob pattern (examples: "**/*.ts", "src/**/*.tsx").',
+              "Find files by glob pattern within the active Location. Returns concise relative file resources. Use a relative path to narrow the search and limit to bound the result count.",
             input: Input,
             output: Output,
             execute: (input, context) =>
               Effect.gen(function* () {
-                const searchPath = input.path === "undefined" || input.path === "null" ? undefined : input.path
-                const source = { type: "tool" as const, messageID: context.messageID, callID: context.callID }
-                const target = yield* mutation.resolve({ path: searchPath ?? ".", kind: "directory" })
-                const external = target.externalDirectory
-                if (external)
-                  yield* permission.assert({
-                    ...LocationMutation.externalDirectoryPermission(external),
-                    sessionID: context.sessionID,
-                    agent: context.agent,
-                    source,
-                  })
                 yield* permission.assert({
                   action: name,
                   resources: [input.pattern],
                   save: ["*"],
                   metadata: {
-                    root: searchPath ?? ".",
-                    path: searchPath,
+                    root: input.path ?? ".",
+                    path: input.path,
                     limit: input.limit,
                   },
                   sessionID: context.sessionID,
                   agent: context.agent,
-                  source,
+                  source: { type: "tool", messageID: context.messageID, callID: context.callID },
                 })
-                const info = yield* fs
-                  .stat(target.canonical)
+                const cwd = path.resolve(location.directory, input.path ?? ".")
+                yield* fs
+                  .stat(cwd)
                   .pipe(
                     Effect.catchReason("PlatformError", "NotFound", () =>
-                      Effect.fail(new ToolFailure({ message: `Search path does not exist: ${searchPath ?? "."}` })),
+                      Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
                     ),
                   )
-                if (info.type !== "Directory")
-                  return yield* Effect.fail(
-                    new ToolFailure({ message: `Search path is not a directory: ${searchPath ?? "."}` }),
-                  )
-                const root = path.resolve(location.directory, searchPath ?? ".")
                 const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
                 const entries = yield* ripgrep
                   .glob({
-                    cwd: target.canonical,
+                    cwd,
                     pattern: input.pattern,
                     limit: limit + 1,
                   })
@@ -108,7 +91,7 @@ export const Plugin = {
                       result.map((entry) =>
                         FileSystem.Entry.make({
                           ...entry,
-                          path: RelativePath.make(path.relative(location.directory, path.resolve(root, entry.path))),
+                          path: RelativePath.make(path.relative(location.directory, path.resolve(cwd, entry.path))),
                         }),
                       ),
                     ),

packages/core/src/tool/grep.ts

@@ -15,9 +15,7 @@ import { Tool } from "./tool"
 export const name = "grep"
 
 export const Input = Schema.Struct({
-  pattern: FileSystem.GrepInput.fields.pattern.check(
-    Schema.isMinLength(1, { message: "Pattern must not be empty" }),
-  ).annotate({
+  pattern: FileSystem.GrepInput.fields.pattern.annotate({
     description: "Regex pattern to search for in file contents",
   }),
   path: RelativePath.pipe(Schema.optional).annotate({
@@ -35,7 +33,7 @@ export const Output = Schema.Array(FileSystem.Match)
 type ModelOutput = typeof Output.Encoded
 
 /** Format raw search matches into the familiar concise model output. */
-export const toModelOutput = (output: ModelOutput, truncated = false) => {
+export const toModelOutput = (output: ModelOutput) => {
   const lines = output.length === 0 ? ["No files found"] : [`Found ${output.length} matches`]
   let current = ""
   for (const match of output) {
@@ -46,11 +44,6 @@ export const toModelOutput = (output: ModelOutput, truncated = false) => {
     }
     lines.push(`  Line ${match.line}: ${match.text}`)
   }
-  if (truncated)
-    lines.push(
-      "",
-      `(Results are truncated: showing first ${output.length} results. Consider using a more specific path or pattern.)`,
-    )
   return lines.join("\n")
 }
 
@@ -96,14 +89,13 @@ export const Plugin = {
                       Effect.fail(new ToolFailure({ message: `Search path does not exist: ${input.path ?? "."}` })),
                     ),
                   )
-                const limit = input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT
-                const matches = yield* ripgrep
+                return yield* ripgrep
                   .grep({
                     cwd: info?.type === "Directory" ? target : path.dirname(target),
                     pattern: input.pattern,
                     file: info?.type === "File" ? path.basename(target) : undefined,
                     include: input.include,
-                    limit: limit + 1,
+                    limit: input.limit ?? FileSystem.DEFAULT_SEARCH_LIMIT,
                   })
                   .pipe(
                     Effect.map((result) =>
@@ -126,18 +118,16 @@ export const Plugin = {
                       ),
                     ),
                   )
-                return { matches: matches.slice(0, limit), truncated: matches.length > limit }
               }).pipe(
-                Effect.map((result) => ({
-                  output: result.matches,
+                Effect.map((output) => ({
+                  output,
                   content: toModelOutput(
-                    result.matches.map((match) => ({
+                    output.map((match) => ({
                       ...match,
                       entry: { ...match.entry, path: path.resolve(location.directory, match.entry.path) },
                     })),
-                    result.truncated,
                   ),
-                  metadata: { matches: result.matches.length, truncated: result.truncated },
+                  metadata: { matches: output.length },
                 })),
                 Effect.mapError((error) =>
                   error instanceof ToolFailure

packages/core/src/tool/question.ts

@@ -17,8 +17,8 @@ export const description = `Use this tool when you need to ask the user question
 4. Offer choices to the user about what direction to take.
 
 Usage notes:
-- A "Type your own answer" option is added automatically; don't include a separate option for free form answers
-- Set \`multiple: true\` to allow selecting more than one option
+- When \`custom\` is enabled (default), a "Type your own answer" option is added automatically; don't include "Other" or catch-all options
+- Answers are returned as arrays of labels; set \`multiple: true\` to allow selecting more than one
 - If you recommend a specific option, make that the first option in the list and add "(Recommended)" at the end of the label`
 
 export const Input = Schema.Struct({
@@ -91,9 +91,6 @@ export const Plugin = {
                       .pipe(Effect.orDie),
                   ),
                   Effect.flatMap((state) => {
-                    // Deliberate defect tunnel (see PermissionV2.assert): a dismissal must dodge
-                    // leaf `mapError` blankets so it never becomes model-facing tool output; it
-                    // resurfaces as a typed failure at SessionModelRequest.executeTool.
                     if (state.status === "cancelled") return Effect.die(new CancelledError())
                     const output = {
                       answers: input.questions.map((_, index): QuestionV2.Answer => {

packages/core/src/tool/skill.ts

@@ -22,7 +22,9 @@ export const Output = Schema.Struct({
   output: Schema.String,
 })
 export const description = [
-  "Load a specialized skill's instructions and resources into the current conversation when the task at hand matches its description.",
+  "Load a specialized skill when the task at hand matches one of the available skills in the instructions.",
+  "",
+  "Use this tool to inject the skill's instructions and resources into the current conversation. The output may contain detailed workflow guidance as well as references to scripts, files, etc. in the same directory as the skill.",
   "",
   "The skill ID must match one of the available skills in the instructions.",
 ].join("\n")

packages/core/src/tool/websearch.ts

@@ -2,122 +2,262 @@ export * as WebSearchTool from "./websearch"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
-import { Effect, Schema } from "effect"
-import { Form } from "../form"
-import { KV } from "../kv"
+import { Context, Duration, Effect, Layer, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { App } from "../app"
+import { PositiveInt } from "../schema"
 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
 
-export const description = `Search the web using the user's selected search integration. Use this for current information beyond knowledge cutoff.
+/**
+ * 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.
 
 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:
+      ["1", "true"].includes(process.env.OPENCODE_EXPERIMENTAL?.toLowerCase() ?? "") ||
+      ["1", "true"].includes(process.env.OPENCODE_ENABLE_EXA?.toLowerCase() ?? "") ||
+      ["1", "true"].includes(process.env.OPENCODE_EXPERIMENTAL_EXA?.toLowerCase() ?? ""),
+    enableParallel:
+      ["1", "true"].includes(process.env.OPENCODE_ENABLE_PARALLEL?.toLowerCase() ?? "") ||
+      ["1", "true"].includes(process.env.OPENCODE_EXPERIMENTAL_PARALLEL?.toLowerCase() ?? ""),
+    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: WebSearch.ID,
-  results: Schema.Array(WebSearch.Result),
+  provider: Provider,
+  text: Schema.String,
 })
 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 forms = yield* Form.Service
-    const kv = yield* KV.Service
 
     yield* ctx.tool
       .transform((draft) =>
         draft.add(
           name,
-          {
+          Tool.make({
             description,
             input: Input,
             output: Output,
-            execute: (input, context) =>
-              Effect.gen(function* () {
+            execute: (input, context) => {
+              const provider = selectProvider(context.sessionID, config, config.provider)
+              return Effect.gen(function* () {
                 yield* permission.assert({
                   action: name,
                   resources: [input.query],
                   save: ["*"],
-                  metadata: input,
+                  metadata: { ...input, provider },
                   sessionID: context.sessionID,
                   agent: context.agent,
                   source: { type: "tool", messageID: context.messageID, callID: context.callID },
                 })
-                const result = yield* ctx.websearch.query(input).pipe(
-                  Effect.catch((error) => {
-                    if (!Schema.is(WebSearch.ProviderRequiredError)(error)) return Effect.fail(error)
-                    return Effect.gen(function* () {
-                      const providers = (yield* ctx.websearch.providers()).data
-                      if (providers.length === 0) return yield* new WebSearch.ProviderRequiredError()
-                      const response = yield* forms.ask({
-                        sessionID: context.sessionID,
-                        title: "Choose a web search provider",
-                        metadata: { kind: "websearch.provider" },
-                        fields: [
-                          {
-                            key: "provider",
-                            title: "Provider",
-                            description: "This becomes your default and can be changed later in configuration.",
-                            type: "string",
-                            required: true,
-                            custom: false,
-                            options: [
-                              ...providers.map((provider) => ({ value: provider.id, label: provider.name })),
-                              { value: "__disable__", label: "Disable web search" },
-                            ],
-                          },
-                        ],
+
+                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,
                       })
-                      if (response.status === "cancelled") return yield* Effect.fail(new Error("Web search cancelled"))
-                      const answer = response.answer.provider
-                      if (answer === "__disable__") {
-                        yield* kv.set("websearch:provider", false)
-                        return yield* new WebSearch.DisabledError()
-                      }
-                      if (typeof answer !== "string" || !providers.some((provider) => provider.id === answer))
-                        return yield* new WebSearch.ProviderRequiredError()
-                      yield* kv.set("websearch:provider", answer)
-                      return yield* ctx.websearch.query(input)
-                    })
-                  }),
-                )
+                    : 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": App.useragent(ctx.app),
+                          ...(config.parallelApiKey ? { Authorization: `Bearer ${config.parallelApiKey}` } : {}),
+                        },
+                      )
                 const output = {
-                  provider: result.data.providerID,
-                  results: result.data.results,
+                  provider,
+                  text: text ?? NO_RESULTS,
                 }
-                const content = output.results.length
-                  ? output.results
-                      .map((result) => {
-                        const title = result.title ?? result.url
-                        const published = result.time.published
-                          ? `\nPublished: ${new Date(result.time.published).toISOString()}`
-                          : ""
-                        return `## [${title}](${result.url})${published}${result.content ? `\n\n${result.content}` : ""}`
-                      })
-                      .join("\n\n")
-                  : NO_RESULTS
-                return { output, content, metadata: { provider: output.provider } }
+                return { output, content: output.text, metadata: { provider: output.provider } }
               }).pipe(
                 Effect.mapError(
                   (error) => new ToolFailure({ message: `Unable to search the web for ${input.query}`, error }),
                 ),
-              ),
-          },
+              )
+            },
+          }),
           { codemode: false },
         ),
       )
       .pipe(Effect.orDie)
-
-    yield* ctx.session.hook("context", (event) =>
-      Effect.gen(function* () {
-        if ((yield* kv.get("websearch:provider")) === false) delete event.tools[name]
-      }),
-    )
   }),
 }

packages/core/src/websearch.ts

@@ -1,144 +0,0 @@
-export * as WebSearch from "./websearch"
-
-import { WebSearch } from "@opencode-ai/schema/websearch"
-import { Context, Effect, Layer, Schema } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { EventV2 } from "./event"
-import { KV } from "./kv"
-import { State } from "./state"
-
-export const ID = WebSearch.ID
-export type ID = WebSearch.ID
-
-export const Provider = WebSearch.Provider
-export type Provider = WebSearch.Provider
-
-export const Event = WebSearch.Event
-
-export const Input = WebSearch.Input
-export type Input = WebSearch.Input
-export type ProviderInput = WebSearch.ProviderInput
-
-export const Result = WebSearch.Result
-export type Result = WebSearch.Result
-
-export const Response = WebSearch.Response
-export type Response = WebSearch.Response
-
-export interface ProviderImplementation extends Provider {
-  readonly execute: (input: ProviderInput) => Effect.Effect<readonly Result[], unknown>
-}
-
-export class ProviderRequiredError extends Schema.TaggedErrorClass<ProviderRequiredError>()(
-  "WebSearch.ProviderRequired",
-  {},
-) {}
-
-export class ProviderNotFoundError extends Schema.TaggedErrorClass<ProviderNotFoundError>()(
-  "WebSearch.ProviderNotFound",
-  {
-    providerID: ID,
-  },
-) {}
-
-export class DisabledError extends Schema.TaggedErrorClass<DisabledError>()("WebSearch.Disabled", {}) {}
-
-export class RequestError extends Schema.TaggedErrorClass<RequestError>()("WebSearch.Request", {
-  providerID: ID,
-  cause: Schema.Defect(),
-}) {}
-
-export type Error = ProviderRequiredError | ProviderNotFoundError | DisabledError | RequestError
-
-export interface Interface extends State.Transformable<Draft> {
-  readonly providers: () => Effect.Effect<readonly Provider[]>
-  readonly default: () => Effect.Effect<Provider | undefined, DisabledError>
-  readonly query: (input: Input) => Effect.Effect<Response, Error>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/WebSearch") {}
-
-type Data = {
-  readonly providers: Map<ID, ProviderImplementation>
-  defaultProviderID?: ID
-}
-
-export type Draft = {
-  add: (provider: ProviderImplementation) => void
-  default: {
-    get: () => ID | undefined
-    set: (providerID: ID) => void
-  }
-}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-    const kv = yield* KV.Service
-    const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result))
-    const state = State.create<Data, Draft>({
-      initial: () => ({ providers: new Map() }),
-      draft: (draft) => ({
-        add: (provider) => draft.providers.set(provider.id, provider),
-        default: {
-          get: () => draft.defaultProviderID,
-          set: (providerID) => (draft.defaultProviderID = providerID),
-        },
-      }),
-      finalize: () => events.publish(Event.Updated, {}).pipe(Effect.asVoid),
-    })
-
-    const requireProvider = (providers: Map<ID, ProviderImplementation>, providerID: ID) => {
-      const provider = providers.get(providerID)
-      return provider ? Effect.succeed(provider) : Effect.fail(new ProviderNotFoundError({ providerID }))
-    }
-
-    const defaultProvider = Effect.fn("WebSearch.default")(function* () {
-      const data = state.get()
-      const configured = data.defaultProviderID ? data.providers.get(data.defaultProviderID) : undefined
-      if (configured) return configured
-      const stored = yield* kv.get("websearch:provider")
-      if (stored === false) return yield* new DisabledError()
-      if (typeof stored !== "string") return
-      return data.providers.get(ID.make(stored))
-    })
-
-    const resolve = Effect.fn("WebSearch.resolve")(function* (input: Input) {
-      const providers = state.get().providers
-      if (input.providerID) return yield* requireProvider(providers, input.providerID)
-      const provider = yield* defaultProvider()
-      if (!provider) return yield* new ProviderRequiredError()
-      return provider
-    })
-
-    return Service.of({
-      transform: state.transform,
-      reload: state.reload,
-      providers: Effect.fn("WebSearch.providers")(function* () {
-        return Array.from(state.get().providers.values(), (provider) => ({
-          id: provider.id,
-          name: provider.name,
-        })).toSorted((a, b) => a.name.localeCompare(b.name))
-      }),
-      default: Effect.fn("WebSearch.defaultInfo")(function* () {
-        const provider = yield* defaultProvider()
-        return provider && { id: provider.id, name: provider.name }
-      }),
-      query: Effect.fn("WebSearch.query")(function* (input) {
-        const provider = yield* resolve(input)
-        const results = yield* provider.execute({ query: input.query }).pipe(
-          Effect.flatMap(decodeResults),
-          Effect.mapError((cause) => new RequestError({ providerID: provider.id, cause })),
-        )
-        return new Response({ providerID: provider.id, results })
-      }),
-    })
-  }),
-)
-
-export const node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [EventV2.node, KV.node],
-})

packages/core/test/codemode/catalog.test.ts

@@ -66,8 +66,20 @@ describe("CodeModeInstructions.render", () => {
     expect(instructions).toContain("- orders (1 tool)")
     expect(instructions).toContain(`  - ${lookup.signature} // Look up an order by ID`)
     expect(instructions).not.toContain("## Search")
-    expect(instructions).toContain("The Code Mode tool catalog below is complete.")
-    expect(instructions).not.toContain("surrounding top-level agent tools")
+    expect(instructions).toContain("Do not infer or normalize tool names")
+    expect(instructions).toContain('`tools.<namespace>["tool-name"](input)`')
+  })
+
+  test("describes the runtime and execution lifecycle concisely", () => {
+    const instructions = render([lookup])
+    expect(instructions).toContain("Run JavaScript to orchestrate tool calls and compose their results.")
+    expect(instructions).toContain("Imports, direct filesystem access, and timers are unavailable.")
+    expect(instructions).toContain("Do not use `fetch`; all external access goes through `tools`.")
+    expect(instructions).toContain(
+      "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
+    )
+    expect(instructions).toContain("any calls still pending when execution ends are interrupted")
+    expect(instructions).toContain("Run independent calls concurrently with `Promise.all`.")
   })
 
   test("adds search guidance when the catalog exceeds the budget", () => {
@@ -75,10 +87,10 @@ describe("CodeModeInstructions.render", () => {
     expect(partial).toContain("## Available tools")
     expect(partial).toContain("- orders (1 tool, none shown)")
     expect(partial).toContain("## Search")
-    expect(partial).toContain("The Code Mode tool catalog below is partial.")
-    expect(partial).not.toContain("surrounding top-level agent tools")
+    expect(partial).toContain("Only some tool signatures are shown.")
     expect(partial).toContain("- search(input: {")
     expect(partial).toContain("  limit?: number,\n  offset?: number,")
+    expect(partial).toContain("or returned by `search`")
     expect(partial).not.toContain("tools.orders.lookup(input:")
   })
 
@@ -113,9 +125,7 @@ describe("CodeModeInstructions.render", () => {
   })
 
   test("renders only the no-tools notice for an empty catalog", () => {
-    expect(render([])).toBe(
-      "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.",
-    )
+    expect(render([])).toBe("No tools are currently available.")
   })
 })
 
@@ -125,8 +135,7 @@ describe("CodeModeInstructions.update", () => {
   test("renders additions, changes, and removals as a compact semantic delta", () => {
     const changed = { ...echo, signature: "tools.notes.echo(input: {\n  text: string,\n}): Promise<string>" }
     const added = entry("notes.list", "List notes")
-    const unchanged = Array.from({ length: 5 }, (_, index) => entry(`stable.tool${index}`, `Stable ${index}`))
-    const text = update([echo, lookup, ...unchanged], [changed, added, ...unchanged])
+    const text = update([echo, lookup], [changed, added])
     expect(text).toContain("The Code Mode tool catalog has changed.")
     expect(text).toContain(`New tools are available in addition to those previously listed:\n  - ${added.signature}`)
     expect(text).toContain(
@@ -160,7 +169,7 @@ describe("CodeModeInstructions.update", () => {
     expect(text).toContain("This catalog supersedes the previous Code Mode tool catalog.")
     expect(text).toContain("## Available tools")
     expect(text).not.toContain("## Search")
-    expect(text).not.toContain("The following tools are no longer available")
+    expect(text).not.toContain("must not be called")
   })
 
   test("renders namespace-only deltas without persisting hidden tool entries", () => {

packages/core/test/codemode/instructions.test.ts

@@ -21,25 +21,6 @@ const lookup: CodeModeCatalog.Entry = {
 }
 
 describe("CodeModeInstructions", () => {
-  it.effect("instructs the model not to call execute while the catalog is empty", () =>
-    Effect.gen(function* () {
-      const initialized = yield* readInitial(CodeModeInstructions.make([]))
-      expect(initialized.text).toBe(
-        "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.",
-      )
-
-      const added = yield* readUpdate(CodeModeInstructions.make([echo]), initialized)
-      expect(added.text).toContain("New tools are available in addition to those previously listed:")
-      expect(added.text).toContain(echo.signature)
-
-      expect(yield* readUpdate(CodeModeInstructions.make([]), { values: added.values })).toMatchObject({
-        text:
-          "The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.\n\n" +
-          "No Code Mode tools are currently available. Later Code Mode catalog updates may add or remove tools. Do not call `execute` unless there is at least one available Code Mode tool.",
-      })
-    }),
-  )
-
   it.effect("renders the initial catalog, semantic deltas, and removal", () =>
     Effect.gen(function* () {
       const initialized = yield* readInitial(CodeModeInstructions.make([echo]))

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

@@ -121,15 +121,23 @@ describe("Config", () => {
               const config = yield* Config.Service
               const entries = yield* config.entries()
               expect(
-                entries.flatMap((entry) => (entry.type === "document" && entry.info.shell ? [entry.info.shell] : [])),
+                entries.flatMap((entry) =>
+                  entry.type === "document" && entry.info.shell ? [entry.info.shell] : [],
+                ),
               ).toEqual(["global", "explicit", "project", "content"])
               expect(Config.latest(entries, "shell")).toBe("content")
             }).pipe(
               Effect.provide(
-                testLayer(project, global, project, undefined, undefined, emptyCredentialNode, emptyWellknownNode, {
-                  file: explicit,
-                  content: JSON.stringify({ shell: "content" }),
-                }),
+                testLayer(
+                  project,
+                  global,
+                  project,
+                  undefined,
+                  undefined,
+                  emptyCredentialNode,
+                  emptyWellknownNode,
+                  { file: explicit, content: JSON.stringify({ shell: "content" }) },
+                ),
               ),
             ),
           ),
@@ -147,24 +155,31 @@ describe("Config", () => {
         const global = path.join(tmp.path, "global")
         const project = path.join(tmp.path, "project")
         return Effect.promise(async () => {
-          await fs.mkdir(global, { recursive: true })
-          await fs.mkdir(project, { recursive: true })
-          await fs.writeFile(path.join(global, "opencode.json"), JSON.stringify({ shell: "global" }))
-          await fs.writeFile(path.join(project, "opencode.json"), JSON.stringify({ shell: "project" }))
-        }).pipe(
-          Effect.andThen(
-            Effect.gen(function* () {
-              const config = yield* Config.Service
-              expect(Config.latest(yield* config.entries(), "shell")).toBe("global")
-            }).pipe(
-              Effect.provide(
-                testLayer(project, global, project, undefined, undefined, emptyCredentialNode, emptyWellknownNode, {
-                  project: false,
-                }),
+            await fs.mkdir(global, { recursive: true })
+            await fs.mkdir(project, { recursive: true })
+            await fs.writeFile(path.join(global, "opencode.json"), JSON.stringify({ shell: "global" }))
+            await fs.writeFile(path.join(project, "opencode.json"), JSON.stringify({ shell: "project" }))
+          }).pipe(
+            Effect.andThen(
+              Effect.gen(function* () {
+                const config = yield* Config.Service
+                expect(Config.latest(yield* config.entries(), "shell")).toBe("global")
+              }).pipe(
+                Effect.provide(
+                  testLayer(
+                    project,
+                    global,
+                    project,
+                    undefined,
+                    undefined,
+                    emptyCredentialNode,
+                    emptyWellknownNode,
+                    { project: false },
+                  ),
+                ),
               ),
             ),
-          ),
-        )
+          )
       }),
     ),
   )

packages/core/test/lib/tool.ts

@@ -32,38 +32,18 @@ export function waitForTool(
   })
 }
 
-export function waitForCodeModeTool(
-  registry: ToolRegistry.Interface,
-  path: string,
-  remaining = 1000,
-): Effect.Effect<ToolRegistry.ToolSet, Error> {
-  return Effect.gen(function* () {
-    const toolSet = yield* registry.snapshot()
-    if (toolSet.codeModeCatalog?.some((tool) => tool.path === path)) return toolSet
-    if (remaining === 0) {
-      return yield* Effect.fail(new Error(`Timed out waiting for Code Mode tool: ${path}`))
-    }
-    yield* Effect.promise(() => Bun.sleep(1))
-    return yield* waitForCodeModeTool(registry, path, remaining - 1)
-  })
-}
-
 /**
  * Registers a core tool plugin's tools against the real registry without booting the
  * full plugin host. Only the tool domain is live; focused tool tests exercise
  * registration, snapshots, and execution through the same path production uses.
  */
-export const registerToolPlugin = <R>(
-  plugin: {
-    readonly id: string
-    readonly effect: (context: PluginContext) => Effect.Effect<void, never, R>
-  },
-  overrides: Parameters<typeof host>[0] = {},
-): Effect.Effect<void, never, R | Tools.Service | Scope.Scope> =>
+export const registerToolPlugin = <R>(plugin: {
+  readonly id: string
+  readonly effect: (context: PluginContext) => Effect.Effect<void, never, R>
+}): Effect.Effect<void, never, R | Tools.Service | Scope.Scope> =>
   Effect.gen(function* () {
     const tools = yield* Tools.Service
     const context = host({
-      ...overrides,
       session: {
         hook: () => Effect.succeed({ dispose: Effect.void }),
       },

packages/core/test/mcp-instructions.test.ts

@@ -93,60 +93,6 @@ describe("McpInstructions", () => {
     ),
   )
 
-  it.effect("keeps MCP instructions when Code Mode is disabled and execute is denied", () =>
-    Effect.gen(function* () {
-      const service = yield* McpInstructions.Service
-      const generation = yield* service
-        .load(selection([{ action: "execute", resource: "*", effect: "deny" }]))
-        .pipe(Effect.flatMap(readInitial))
-
-      expect(generation.text).toBe(
-        [
-          "<mcp_instructions>",
-          '  <server name="alpha">',
-          "    Alpha instructions",
-          "  </server>",
-          "</mcp_instructions>",
-        ].join("\n"),
-      )
-    }).pipe(
-      Effect.provide(
-        layer(
-          () => [instructions("alpha", "Alpha instructions")],
-          () => [new MCP.Tool({ server: MCP.ServerName.make("alpha"), name: "search", codemode: false })],
-        ),
-      ),
-    ),
-  )
-
-  it.effect("restates guidance when Code Mode is disabled for a server", () => {
-    let tools = [tool("alpha")]
-    return Effect.gen(function* () {
-      const service = yield* McpInstructions.Service
-      const initialized = yield* service.load(selection()).pipe(Effect.flatMap(readInitial))
-
-      tools = [new MCP.Tool({ server: MCP.ServerName.make("alpha"), name: "search", codemode: false })]
-      const changed = yield* readUpdate(yield* service.load(selection()), initialized)
-      expect(changed.text).toBe(
-        [
-          "The available MCP server instructions have changed. This list supersedes the previous one.",
-          "<mcp_instructions>",
-          '  <server name="alpha">',
-          "    Alpha instructions",
-          "  </server>",
-          "</mcp_instructions>",
-        ].join("\n"),
-      )
-    }).pipe(
-      Effect.provide(
-        layer(
-          () => [instructions("alpha", "Alpha instructions")],
-          () => tools,
-        ),
-      ),
-    )
-  })
-
   it.effect("renders additions, changes, and removal", () => {
     let catalog = [instructions("alpha", "Alpha instructions")]
     const tools = [tool("alpha"), tool("beta")]

packages/core/test/mcp.test.ts

@@ -33,7 +33,7 @@ import { Image } from "@opencode-ai/core/image"
 import { testEffect } from "./lib/effect"
 import { imagePassthrough } from "./lib/image"
 import { location } from "./fixture/location"
-import { executeTool, toolDefinitions, toolIdentity, waitForCodeModeTool, waitForTool } from "./lib/tool"
+import { executeTool, toolDefinitions, toolIdentity, waitForTool } from "./lib/tool"
 
 let assertion: Deferred.Deferred<PermissionV2.AssertInput> | undefined
 let decision: Effect.Effect<void, PermissionV2.Error> = Effect.void
@@ -802,16 +802,10 @@ test("serializes concurrent MCP lifecycle operations", async () => {
 it.effect("advertises MCP output schemas to Code Mode", () =>
   Effect.gen(function* () {
     const registry = yield* ToolRegistry.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
-    const execute = toolSet.definitions.find((tool) => tool.name === "execute")
+    yield* waitForTool(registry, "execute")
+    const definitions = yield* toolDefinitions(registry)
+    const execute = definitions.find((tool) => tool.name === "execute")
 
-    expect(toolSet.definitions.map((tool) => tool.name)).toEqual([
-      "direct_fail",
-      "direct_lookup",
-      "direct_media",
-      "execute",
-    ])
-    expect(toolSet.codeModeCatalog?.find((tool) => tool.path === "demo.search")?.signature).toContain("ok: boolean")
     expect(execute?.description).not.toContain("tools.demo.search")
   }),
 )
@@ -879,9 +873,9 @@ it.effect("waits for permission before calling an MCP tool", () =>
     const permission = yield* Deferred.make<void>()
     decision = Deferred.await(permission)
     const registry = yield* ToolRegistry.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
+    yield* waitForTool(registry, "execute")
 
-    const fiber = yield* toolSet.execute({
+    const fiber = yield* executeTool(registry, {
       sessionID: SessionV2.ID.make("ses_mcp_permission"),
       ...toolIdentity,
       call: {
@@ -918,9 +912,9 @@ it.effect("does not call MCP when permission is blocked", () =>
     assertion = yield* Deferred.make<PermissionV2.AssertInput>()
     decision = Effect.fail(new PermissionV2.BlockedError({ rules: [], permission: "demo_search", resources: ["*"] }))
     const registry = yield* ToolRegistry.Service
-    const toolSet = yield* waitForCodeModeTool(registry, "demo.search")
+    yield* waitForTool(registry, "execute")
 
-    const execution = yield* toolSet.execute({
+    const execution = yield* executeTool(registry, {
       sessionID: SessionV2.ID.make("ses_mcp_blocked"),
       ...toolIdentity,
       call: {

packages/core/test/npm.test.ts

@@ -64,3 +64,29 @@ describe("Npm.add", () => {
     expect(entries.fallback.entrypoint).toEndWith("/index.js")
   })
 })
+
+describe("Npm.install", () => {
+  test("respects omit from project .npmrc", async () => {
+    await using tmp = await tmpdir()
+
+    await writePackage(tmp.path, {
+      name: "fixture",
+      dependencies: {
+        "prod-pkg": "file:./prod-pkg",
+      },
+      devDependencies: {
+        "dev-pkg": "file:./dev-pkg",
+      },
+    })
+    await Bun.write(path.join(tmp.path, ".npmrc"), "omit=dev\n")
+    await fs.mkdir(path.join(tmp.path, "prod-pkg"))
+    await fs.mkdir(path.join(tmp.path, "dev-pkg"))
+    await writePackage(path.join(tmp.path, "prod-pkg"), { name: "prod-pkg" })
+    await writePackage(path.join(tmp.path, "dev-pkg"), { name: "dev-pkg" })
+
+    await Npm.install(tmp.path)
+
+    await expect(fs.stat(path.join(tmp.path, "node_modules", "prod-pkg"))).resolves.toBeDefined()
+    await expect(fs.stat(path.join(tmp.path, "node_modules", "dev-pkg"))).rejects.toThrow()
+  })
+})

packages/core/test/plugin/fixture.ts

@@ -2,7 +2,6 @@ import { AgentV2 } from "@opencode-ai/core/agent"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { CommandV2 } from "@opencode-ai/core/command"
-import { Config } from "@opencode-ai/core/config"
 import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
@@ -10,7 +9,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { EventV2 } from "@opencode-ai/core/event"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Form } from "@opencode-ai/core/form"
 import { Integration } from "@opencode-ai/core/integration"
 import { Location } from "@opencode-ai/core/location"
 import { Npm } from "@opencode-ai/util/npm"
@@ -21,7 +19,6 @@ import { Reference } from "@opencode-ai/core/reference"
 import { SkillV2 } from "@opencode-ai/core/skill"
 import { ToolHooks } from "@opencode-ai/core/tool/hooks"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
-import { WebSearch } from "@opencode-ai/core/websearch"
 import { Effect, Layer } from "effect"
 import { tempLocationLayer } from "../fixture/location"
 
@@ -42,7 +39,6 @@ export const PluginTestLayer = AppNodeBuilder.build(
     Npm.node,
     Credential.node,
     EventV2.node,
-    Form.node,
     LayerNodePlatform.httpClient,
     PluginV2.node,
     AgentV2.node,
@@ -56,11 +52,9 @@ export const PluginTestLayer = AppNodeBuilder.build(
     SkillV2.node,
     ToolHooks.node,
     ToolRegistry.toolsNode,
-    WebSearch.node,
   ]),
   [
     [Location.node, tempLocationLayer],
     [Npm.node, npmLayer],
-    [Config.node, Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))],
   ],
 ) as unknown as Layer.Layer<unknown, never>

packages/core/test/plugin/host.ts

@@ -1,16 +1,11 @@
-import { Plugin } from "@opencode-ai/plugin/v2/effect"
+import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 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 { Location } from "@opencode-ai/core/location"
 import { ModelV2 } from "@opencode-ai/core/model"
-import { Project } from "@opencode-ai/core/project"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { WebSearch } from "@opencode-ai/core/websearch"
 import type {
-  CredentialOAuth,
   IntegrationCommandMethod,
   IntegrationEnvMethod,
   IntegrationKeyMethod,
@@ -18,11 +13,11 @@ import type {
 } from "@opencode-ai/sdk/v2/types"
 import { Effect, Stream } from "effect"
 
-type Overrides = Partial<Omit<Plugin.Context, "options" | "session">> & {
-  readonly session?: Partial<Plugin.Context["session"]>
+type Overrides = Partial<Omit<PluginContext, "options" | "session">> & {
+  readonly session?: Partial<PluginContext["session"]>
 }
 
-export function host(overrides: Overrides = {}): Plugin.Context {
+export function host(overrides: Overrides = {}): PluginContext {
   return {
     app: overrides.app ?? { name: "test", version: "test", channel: "test" },
     options: {},
@@ -97,12 +92,6 @@ export function host(overrides: Overrides = {}): Plugin.Context {
       transform: () => Effect.die("unused tool.transform"),
       hook: () => Effect.die("unused tool.hook"),
     },
-    websearch: overrides.websearch ?? {
-      providers: () => Effect.die("unused websearch.providers"),
-      query: () => Effect.die("unused websearch.query"),
-      transform: () => Effect.die("unused websearch.transform"),
-      reload: () => Effect.die("unused websearch.reload"),
-    },
     session: {
       hook: overrides.session?.hook ?? (() => Effect.die("unused session.hook")),
       create: overrides.session?.create ?? (() => Effect.die("unused session.create")),
@@ -116,7 +105,7 @@ export function host(overrides: Overrides = {}): Plugin.Context {
   }
 }
 
-export function agentHost(agent: AgentV2.Interface): Plugin.Context["agent"] {
+export function agentHost(agent: AgentV2.Interface): PluginContext["agent"] {
   return {
     get: (id) => agent.get(AgentV2.ID.make(id)).pipe(Effect.map((value) => value && agentInfo(value))),
     list: () => Effect.die("unused agent.list"),
@@ -142,7 +131,7 @@ export function agentHost(agent: AgentV2.Interface): Plugin.Context["agent"] {
   }
 }
 
-export function catalogHost(catalog: Catalog.Interface): Plugin.Context["catalog"] {
+export function catalogHost(catalog: Catalog.Interface): PluginContext["catalog"] {
   return {
     provider: {
       list: () => Effect.die("unused catalog.provider.list"),
@@ -218,7 +207,7 @@ export function catalogHost(catalog: Catalog.Interface): Plugin.Context["catalog
   }
 }
 
-export function integrationHost(integration: Integration.Interface): Plugin.Context["integration"] {
+export function integrationHost(integration: Integration.Interface): PluginContext["integration"] {
   return {
     list: () => Effect.die("unused integration.list"),
     get: () => Effect.die("unused integration.get"),
@@ -340,40 +329,6 @@ export function integrationHost(integration: Integration.Interface): Plugin.Cont
   }
 }
 
-export function webSearchHost(websearch: WebSearch.Interface): Plugin.Context["websearch"] {
-  const location = Location.Info.make({
-    directory: AbsolutePath.make("/tmp/websearch-test"),
-    project: { id: Project.ID.make("websearch-test"), directory: AbsolutePath.make("/tmp/websearch-test") },
-  })
-  return {
-    providers: () => websearch.providers().pipe(Effect.map((data) => ({ location, data }))),
-    query: (input) =>
-      websearch
-        .query({ query: input.query, providerID: input.providerID && WebSearch.ID.make(input.providerID) })
-        .pipe(Effect.map((data) => ({ location, data }))),
-    reload: websearch.reload,
-    transform: (callback) =>
-      websearch.transform((draft) => {
-        callback({
-          add: (definition) =>
-            draft.add({
-              id: WebSearch.ID.make(definition.id),
-              name: definition.name,
-              execute: definition.execute,
-            }),
-          default: {
-            get: draft.default.get,
-            set: (providerID) => draft.default.set(WebSearch.ID.make(providerID)),
-          },
-        })
-      }),
-  }
-}
-
-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

@@ -8,7 +8,6 @@ import { PluginV2 } from "@opencode-ai/core/plugin"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginPromise } from "@opencode-ai/core/plugin/promise"
-import { WebSearch } from "@opencode-ai/core/websearch"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionPending } from "@opencode-ai/core/session/pending"
@@ -245,38 +244,6 @@ describe("fromPromise", () => {
     }),
   )
 
-  it.effect("registers a standalone web search provider", () =>
-    Effect.gen(function* () {
-      const websearch = yield* WebSearch.Service
-      const plugin = yield* PluginV2.Service
-      const host = yield* PluginHost.make(plugin)
-      const promisePlugin = Plugin.define({
-        id: "promise-websearch",
-        setup: async (ctx) => {
-          await ctx.websearch.transform((draft) => {
-            draft.add({
-              id: "promise-websearch",
-              name: "Promise Web Search",
-              execute: async (input) => [{ url: "https://example.com", content: `promise: ${input.query}`, time: {} }],
-            })
-          })
-        },
-      })
-
-      yield* PluginPromise.fromPromise(promisePlugin).effect(host)
-      expect(yield* websearch.providers()).toContainEqual({
-        id: WebSearch.ID.make("promise-websearch"),
-        name: "Promise Web Search",
-      })
-      expect(yield* websearch.query({ query: "effect", providerID: WebSearch.ID.make("promise-websearch") })).toEqual(
-        new WebSearch.Response({
-          providerID: WebSearch.ID.make("promise-websearch"),
-          results: [{ url: "https://example.com", content: "promise: effect", time: {} }],
-        }),
-      )
-    }),
-  )
-
   it.effect("runs the setup cleanup when the plugin scope closes", () =>
     Effect.gen(function* () {
       const plugin = yield* PluginV2.Service

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

@@ -1,50 +0,0 @@
-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/util/effect/layer-node"
-import { Credential } from "@opencode-ai/core/credential"
-import { Config } from "@opencode-ai/core/config"
-import { EventV2 } from "@opencode-ai/core/event"
-import { Form } from "@opencode-ai/core/form"
-import { Integration } from "@opencode-ai/core/integration"
-import { WebSearch } from "@opencode-ai/core/websearch"
-import { testEffect } from "../lib/effect"
-
-interface WebSearchRequest {
-  readonly url: string
-  readonly headers: Record<string, string>
-  readonly body: unknown
-}
-
-export const requests: WebSearchRequest[] = []
-let responseBody = ""
-
-export function resetWebSearchFixture(body: string) {
-  requests.length = 0
-  responseBody = 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(responseBody, { status: 200 }))
-    }),
-  ),
-)
-
-export const webSearchIntegrationTest = testEffect(
-  Layer.merge(
-    AppNodeBuilder.build(
-      LayerNode.group([Integration.node, Credential.node, EventV2.node, Form.node, WebSearch.node]),
-      [[Config.node, Layer.succeed(Config.Service, Config.Service.of({ entries: () => Effect.succeed([]) }))]],
-    ),
-    http,
-  ),
-)

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

@@ -1,170 +0,0 @@
-import { beforeEach, describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { Integration } from "@opencode-ai/core/integration"
-import { WebSearch } from "@opencode-ai/core/websearch"
-import { WebSearchExa } from "@opencode-ai/core/plugin/websearch/exa"
-import { WebSearchParallel } from "@opencode-ai/core/plugin/websearch/parallel"
-import { host, integrationHost, webSearchHost } 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: "Title: Effect\nURL: https://effect.website\nPublished: 2026-07-25T00:00:00.000Z\nAuthor: N/A\nHighlights:\nEffect documentation",
-            _meta: { searchTime: 123 },
-          },
-        ],
-      },
-    })}\n\n`,
-  )
-})
-
-const it = webSearchIntegrationTest
-
-describe("built-in web search providers", () => {
-  it.effect("registers a provider without an integration", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const websearch = yield* WebSearch.Service
-      const registration = yield* webSearchHost(websearch).transform((draft) => {
-        draft.add({
-          id: "test-websearch",
-          name: "Test Web Search",
-          execute: (input) => Effect.succeed([{ url: "https://example.com", content: input.query, time: {} }]),
-        })
-      })
-
-      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toBeUndefined()
-      expect(yield* websearch.providers()).toContainEqual({
-        id: WebSearch.ID.make("test-websearch"),
-        name: "Test Web Search",
-      })
-      yield* registration.dispose
-      expect(yield* websearch.providers()).not.toContainEqual({
-        id: WebSearch.ID.make("test-websearch"),
-        name: "Test Web Search",
-      })
-    }),
-  )
-
-  it.effect("registers Exa with its MCP schema", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const websearch = yield* WebSearch.Service
-      yield* WebSearchExa.Plugin.effect(
-        host({ integration: integrationHost(integrations), websearch: webSearchHost(websearch) }),
-      )
-
-      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"] }],
-      })
-      yield* integrations.connection.key({ integrationID: Integration.ID.make("exa"), key: "exa secret" })
-      expect(yield* websearch.query({ query: "effect typescript", providerID: WebSearch.ID.make("exa") })).toEqual(
-        new WebSearch.Response({
-          providerID: WebSearch.ID.make("exa"),
-          results: [
-            {
-              url: "https://effect.website",
-              title: "Effect",
-              content: "Effect documentation",
-              time: { published: Date.parse("2026-07-25T00:00:00.000Z") },
-            },
-          ],
-        }),
-      )
-      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
-      const websearch = yield* WebSearch.Service
-      yield* WebSearchParallel.Plugin.effect(
-        host({ integration: integrationHost(integrations), websearch: webSearchHost(websearch) }),
-      )
-      yield* integrations.connection.key({ integrationID: Integration.ID.make("parallel"), key: "parallel-secret" })
-
-      const output = yield* websearch.query({
-        query: "effect layers",
-        providerID: WebSearch.ID.make("parallel"),
-      })
-      expect(output).toEqual(
-        new WebSearch.Response({
-          providerID: WebSearch.ID.make("parallel"),
-          results: [
-            {
-              url: "https://effect.website",
-              title: "Effect",
-              content: "Effect documentation",
-              time: {},
-            },
-          ],
-        }),
-      )
-      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"],
-            },
-          },
-        },
-      })
-      expect(JSON.stringify(output)).not.toContain("parallel-secret")
-    }),
-  )
-})

packages/core/test/prompt-cache-diagnostics.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "bun:test"
+import { GenerationOptions, LLM, LLMRequest, Message, Model, ToolDefinition } from "@opencode-ai/ai"
+import { OpenAIChat } from "@opencode-ai/ai/protocols"
+import { PromptCacheDiagnostics } from "@opencode-ai/core/session/prompt-cache-diagnostics"
+
+const model = Model.make({ id: "test", provider: "test", route: OpenAIChat.route })
+const tool = ToolDefinition.make({
+  name: "read",
+  description: "Read a file",
+  inputSchema: { type: "object", properties: {} },
+})
+
+const request = LLM.request({
+  model,
+  system: "System",
+  prompt: "First",
+  tools: [tool],
+})
+const compare = (current: LLMRequest) =>
+  PromptCacheDiagnostics.compare(PromptCacheDiagnostics.snapshot(request), PromptCacheDiagnostics.snapshot(current))
+
+describe("PromptCacheDiagnostics", () => {
+  test("distinguishes initial and stable requests", () => {
+    const snapshot = PromptCacheDiagnostics.snapshot(request)
+    expect(PromptCacheDiagnostics.compare(undefined, snapshot)).toEqual({ status: "initial" })
+    expect(PromptCacheDiagnostics.compare(snapshot, snapshot)).toEqual({ status: "stable", messages: 1 })
+  })
+
+  test("recognizes append-only history", () => {
+    const current = LLMRequest.update(request, { messages: [...request.messages, Message.assistant("Second")] })
+    expect(compare(current)).toEqual({ status: "append-only", previousMessages: 1, currentMessages: 2 })
+  })
+
+  test("detects cache-sensitive setting changes", () => {
+    const current = LLMRequest.update(request, { generation: GenerationOptions.make({ temperature: 0.5 }) })
+    expect(compare(current)).toEqual({ status: "changed", component: "settings", index: 0, label: "model settings" })
+  })
+
+  test("finds the first changed prefix component", () => {
+    const changedTool = ToolDefinition.make({ ...tool, description: "Read one file" })
+    const current = LLMRequest.update(request, { tools: [changedTool] })
+    expect(compare(current)).toEqual({ status: "changed", component: "tools", index: 0, label: "read" })
+  })
+
+  test("treats appended tools as a prefix change", () => {
+    const write = ToolDefinition.make({
+      name: "write",
+      description: "Write a file",
+      inputSchema: { type: "object", properties: {} },
+    })
+    const current = LLMRequest.update(request, { tools: [...request.tools, write] })
+    expect(compare(current)).toEqual({ status: "changed", component: "tools", index: 1, label: "write" })
+  })
+})

packages/core/test/session-execution.test.ts

@@ -105,31 +105,6 @@ describe("SessionExecution lifecycle", () => {
     }),
   )
 
-  it.effect("starts every suspended execution without waiting for earlier drains to finish", () =>
-    Effect.gen(function* () {
-      const database = yield* Database.Service
-      const sessionIDs = Array.from({ length: 5 }, (_, index) => SessionV2.ID.make(`ses_resume_concurrent_${index}`))
-      yield* seedSessions(database, sessionIDs, { time_suspended: Date.now() })
-
-      const fourStarted = yield* Deferred.make<void>()
-      const started: SessionV2.ID[] = []
-      const scope = yield* Scope.make()
-      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
-      const context = yield* buildExecution(scope, ({ sessionID }) =>
-        Effect.sync(() => {
-          started.push(sessionID)
-          if (started.length === 4) Deferred.doneUnsafe(fourStarted, Effect.void)
-        }).pipe(Effect.andThen(Effect.never)),
-      )
-      const execution = Context.get(context, SessionExecution.Service)
-      const restart = Context.get(context, SessionRestart.Service)
-      yield* restart.resumeSuspendedSessions.pipe(Effect.forkIn(scope))
-      yield* Deferred.await(fourStarted)
-
-      expect([...(yield* execution.active)].toSorted()).toEqual(sessionIDs.toSorted())
-    }),
-  )
-
   it.effect("resumes each suspended Session at most once", () =>
     Effect.gen(function* () {
       const database = yield* Database.Service
@@ -140,11 +115,9 @@ describe("SessionExecution lifecycle", () => {
       const drained: string[] = []
       const scope = yield* Scope.make()
       const context = yield* buildExecution(scope, ({ sessionID }) => Effect.sync(() => void drained.push(sessionID)))
-      const execution = Context.get(context, SessionExecution.Service)
       const restart = Context.get(context, SessionRestart.Service)
 
       yield* restart.resumeSuspendedSessions
-      yield* Effect.forEach([first, second], execution.awaitIdle, { discard: true })
       expect(drained.toSorted()).toEqual([first, second])
       expect(yield* suspensions(database)).toEqual({ [first]: false, [second]: false })
 

packages/core/test/session-runner-message.test.ts

@@ -767,35 +767,4 @@ Recent work
       },
     ])
   })
-
-  test("preserves assistant text provider state across same-provider model changes and failures", () => {
-    const messages = toLLMMessages(
-      [
-        SessionMessage.Assistant.make({
-          id: id("assistant-phase"),
-          type: "assistant",
-          agent: build,
-          model: { id: ModelV2.ID.make("old"), providerID: ProviderV2.ID.make("provider") },
-          content: [
-            SessionMessage.AssistantText.make({
-              type: "text",
-              text: "Checking.",
-              state: { phase: "commentary" },
-            }),
-          ],
-          error: { type: "provider.unknown", message: "Interrupted after commentary" },
-          time: { created, completed: created },
-        }),
-      ],
-      ModelV2.Ref.make({ id: ModelV2.ID.make("new"), providerID: ProviderV2.ID.make("provider") }),
-    )
-
-    expect(messages[0]?.content).toEqual([
-      {
-        type: "text",
-        text: "Checking.",
-        providerMetadata: { provider: { phase: "commentary" } },
-      },
-    ])
-  })
 })

packages/core/test/session-runner-recorded.test.ts

@@ -186,7 +186,6 @@ describe("SessionRunnerLLM recorded", () => {
       yield* agents.transform((draft) =>
         draft.update(AgentV2.ID.make("build"), (agent) => {
           agent.mode = "primary"
-          agent.permissions.push({ action: "execute", resource: "*", effect: "deny" })
         }),
       )
       const pluginHost = host({

packages/core/test/session-runner-tool-events.test.ts

@@ -259,7 +259,7 @@ test("step finish records settlement without publishing step ended", async () =>
   await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } })))
 
   expect(published.some((event) => event.type === "step.ended.2")).toBe(false)
-  expect(publisher.record().finish).toMatchObject({ finish: "stop" })
+  expect(publisher.stepSettlement()).toMatchObject({ finish: "stop" })
 })
 
 test("content-filter finish retains failure evidence until step closeout", async () => {
@@ -280,7 +280,7 @@ test("content-filter finish retains failure evidence until step closeout", async
   )
 
   expect(published.map((event) => event.type)).toEqual(["session.step.started.1"])
-  const settlement = publisher.record().finish
+  const settlement = publisher.stepSettlement()
   expect(settlement).toMatchObject({
     finish: "content-filter",
     tokens: { input: 8, output: 2, reasoning: 1 },

packages/core/test/session-runner-tool-registry.test.ts

@@ -88,7 +88,7 @@ describe("ToolRegistry", () => {
 
       expect(error).toBeInstanceOf(Tool.RegistrationError)
       expect(error.message).toBe('Invalid tool namespace: "slack..admin"')
-      expect((yield* service.snapshot()).definitions.map((tool) => tool.name)).toEqual(["execute"])
+      expect((yield* service.snapshot()).definitions).toEqual([])
     }),
   )
 
@@ -102,7 +102,7 @@ describe("ToolRegistry", () => {
         .register({ "echo.tool": make(), echo_tool: make() }, { codemode: false })
         .pipe(Effect.flip)
       expect(collision.message).toBe("Duplicate normalized tool name: echo_tool")
-      expect((yield* service.snapshot()).definitions.map((tool) => tool.name)).toEqual(["execute"])
+      expect((yield* service.snapshot()).definitions).toEqual([])
     }),
   )
 
@@ -117,7 +117,7 @@ describe("ToolRegistry", () => {
         .pipe(Effect.flip)
 
       expect(error).toBeInstanceOf(Tool.RegistrationError)
-      expect((yield* service.snapshot()).definitions.map((tool) => tool.name)).toEqual(["execute"])
+      expect((yield* service.snapshot()).definitions).toEqual([])
     }),
   )
 
@@ -148,20 +148,6 @@ describe("ToolRegistry", () => {
     }),
   )
 
-  it.effect("keeps execute available without Code Mode tools unless explicitly denied", () =>
-    Effect.gen(function* () {
-      const service = yield* ToolRegistry.Service
-
-      const available = yield* service.snapshot()
-      expect(available.definitions.map((tool) => tool.name)).toEqual(["execute"])
-      expect(available.codeModeCatalog).toEqual([])
-
-      const denied = yield* service.snapshot([{ action: "execute", resource: "*", effect: "deny" }])
-      expect(denied.definitions).toEqual([])
-      expect(denied.codeModeCatalog).toBeUndefined()
-    }),
-  )
-
   it.effect("filters disabled tools with edit aliases and ordered wildcard precedence", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
@@ -170,12 +156,7 @@ describe("ToolRegistry", () => {
       const names = (permissions: PermissionV2.Ruleset) =>
         toolDefinitions(service, permissions).pipe(Effect.map((definitions) => definitions.map((tool) => tool.name)))
 
-      expect(yield* names([{ action: "question", resource: "*", effect: "deny" }])).toEqual([
-        "bash",
-        "edit",
-        "write",
-        "execute",
-      ])
+      expect(yield* names([{ action: "question", resource: "*", effect: "deny" }])).toEqual(["bash", "edit", "write"])
       expect(
         yield* names([
           { action: "*", resource: "*", effect: "deny" },
@@ -188,11 +169,7 @@ describe("ToolRegistry", () => {
           { action: "*", resource: "*", effect: "deny" },
         ]),
       ).toEqual([])
-      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual([
-        "bash",
-        "question",
-        "execute",
-      ])
+      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual(["bash", "question"])
     }),
   )
 
@@ -205,7 +182,7 @@ describe("ToolRegistry", () => {
 
       expect(
         (yield* toolDefinitions(service, [{ action: "edit", resource: "*", effect: "deny" }])).map((tool) => tool.name),
-      ).toEqual(["first", "execute"])
+      ).toEqual(["first"])
     }),
   )
 
@@ -214,9 +191,9 @@ describe("ToolRegistry", () => {
       const service = yield* ToolRegistry.Service
       const scope = yield* Scope.make()
       yield* service.register({ echo: make() }, { codemode: false }).pipe(Scope.provide(scope))
-      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["echo", "execute"])
+      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["echo"])
       yield* Scope.close(scope, Exit.void)
-      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["execute"])
+      expect(yield* toolDefinitions(service)).toEqual([])
     }),
   )
 
@@ -236,9 +213,9 @@ describe("ToolRegistry", () => {
       yield* Deferred.await(registered)
       yield* Fiber.interrupt(fiber)
 
-      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["echo", "execute"])
+      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["echo"])
       yield* Scope.close(scope, Exit.void)
-      expect((yield* toolDefinitions(service)).map((tool) => tool.name)).toEqual(["execute"])
+      expect(yield* toolDefinitions(service)).toEqual([])
     }),
   )
 
@@ -538,7 +515,7 @@ describe("ToolRegistry", () => {
     }),
   )
 
-  it.effect("executes and reports progress for codemode tools advertised in a model request", () =>
+  it.effect("executes codemode tools advertised in a model request", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
       const executed: string[] = []
@@ -549,11 +526,8 @@ describe("ToolRegistry", () => {
             description: "Echo text",
             input: Schema.Struct({ text: Schema.String }),
             output: Schema.Struct({ text: Schema.String }),
-            execute: ({ text }, context) =>
-              Effect.sync(() => executed.push(`old:${text}`)).pipe(
-                Effect.andThen(context.progress({ stage: "old" })),
-                Effect.as({ output: { text } }),
-              ),
+            execute: ({ text }) =>
+              Effect.sync(() => executed.push(`old:${text}`)).pipe(Effect.as({ output: { text } })),
           }),
         })
         .pipe(Scope.provide(scope))
@@ -572,7 +546,6 @@ describe("ToolRegistry", () => {
         }),
       })
 
-      const progress: ToolRegistry.Progress[] = []
       const execution = yield* toolSet.execute({
         ...call("execute"),
         call: {
@@ -581,15 +554,10 @@ describe("ToolRegistry", () => {
           name: "execute",
           input: { code: 'return await tools.echo({ text: "request" })' },
         },
-        progress: (update) => Effect.sync(() => progress.push(update)),
       })
 
       expect(execution).toMatchObject({ status: "completed", content: [{ type: "text" }] })
       expect(executed).toEqual(["old:request"])
-      expect(progress).toEqual([
-        { toolCalls: [{ tool: "echo", status: "running", input: { text: "request" } }] },
-        { toolCalls: [{ tool: "echo", status: "completed", input: { text: "request" } }] },
-      ])
     }),
   )
 })

packages/core/test/session-runner.test.ts

@@ -880,46 +880,6 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("advertises execute and durable guidance for an empty Code Mode catalog", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      const empty = {
-        catalog: [],
-        tool: Tool.make({
-          description: "Execute Code Mode",
-          input: Schema.Struct({ code: Schema.String }),
-          output: Schema.String,
-          execute: () => Effect.succeed({ output: "unused" }),
-        }),
-      }
-      codeModeMaterializations = [empty, empty, {}]
-      yield* admit(session, "Continue without Code Mode tools")
-      response = reply.stop()
-
-      yield* session.resume(sessionID)
-      yield* admit(session, "Still no Code Mode tools")
-      yield* session.resume(sessionID)
-      yield* admit(session, "Code Mode denied")
-      yield* session.resume(sessionID)
-
-      expect(requests).toHaveLength(3)
-      expect(requests[0]?.tools.map((tool) => tool.name)).toEqual(["defect", "echo", "storefail", "execute"])
-      expect(requests[0]?.system.some((part) => part.text.includes("Do not call `execute`"))).toBe(true)
-      expect(requests[1]?.tools.map((tool) => tool.name)).toEqual(["defect", "echo", "storefail", "execute"])
-      expect(requests[1]?.messages.filter((message) => message.role === "system")).toEqual([])
-      expect(requests[2]?.tools.map((tool) => tool.name)).toEqual(["defect", "echo", "storefail"])
-      expect(
-        requests[2]?.messages.some(
-          (message) =>
-            message.role === "system" &&
-            message.content.some(
-              (part) => part.type === "text" && part.text.includes("Code Mode tools are no longer available"),
-            ),
-        ),
-      ).toBe(true)
-    }),
-  )
-
   it.effect("applies session context hooks without exposing unavailable tools", () =>
     Effect.gen(function* () {
       const session = yield* setup
@@ -2672,47 +2632,6 @@ describe("SessionRunnerLLM", () => {
     }),
   )
 
-  it.effect("restores durable text provider metadata in the next request", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Check first")
-
-      response = [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.textStart({ id: "commentary", providerMetadata: { openai: { phase: "commentary" } } }),
-        LLMEvent.textDelta({ id: "commentary", text: "Checking." }),
-        LLMEvent.textEnd({
-          id: "commentary",
-          providerMetadata: { openai: { phase: "commentary" }, anthropic: { ignored: true } },
-        }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
-      ]
-      yield* session.resume(sessionID)
-      yield* replaySessionProjection(sessionID)
-
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Check first" },
-        {
-          type: "assistant",
-          content: [{ type: "text", text: "Checking.", state: { phase: "commentary" } }],
-        },
-      ])
-
-      yield* admit(session, "Continue")
-      response = []
-      yield* session.resume(sessionID)
-
-      expect(requests[1]?.messages[1]?.content).toEqual([
-        {
-          type: "text",
-          text: "Checking.",
-          providerMetadata: { openai: { phase: "commentary" } },
-        },
-      ])
-    }),
-  )
-
   it.effect("replays durable provider-executed tool results inline in the next request", () =>
     Effect.gen(function* () {
       const session = yield* setup
@@ -3650,7 +3569,7 @@ describe("SessionRunnerLLM", () => {
             {
               type: "tool",
               id: "call-declined",
-              state: { status: "error", error: { type: "aborted", message: "The user declined this tool call" } },
+              state: { status: "error", error: { message: "Tool execution interrupted" } },
             },
           ],
         },
@@ -3802,7 +3721,7 @@ describe("SessionRunnerLLM", () => {
             {
               type: "tool",
               id: "call-question",
-              state: { status: "error", error: { type: "aborted", message: "The user dismissed this question" } },
+              state: { status: "error", error: { type: "aborted", message: "Tool execution interrupted" } },
             },
           ],
         },

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

@@ -137,12 +137,10 @@ describe("EditTool", () => {
           Effect.andThen(
             withTool(tmp.path, (registry) =>
               Effect.gen(function* () {
-                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["edit", "execute"])
-                expect(
-                  (yield* toolDefinitions(registry, [{ action: "edit", resource: "*", effect: "deny" }])).map(
-                    (tool) => tool.name,
-                  ),
-                ).toEqual(["execute"])
+                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["edit"])
+                expect(yield* toolDefinitions(registry, [{ action: "edit", resource: "*", effect: "deny" }])).toEqual(
+                  [],
+                )
                 const settled = yield* executeTool(
                   registry,
                   call({ path: "hello.txt", oldString: "before", newString: "after" }),

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

@@ -4,7 +4,7 @@ import { Tool } from "@opencode-ai/core/tool/tool"
 import { Agent } from "@opencode-ai/schema/agent"
 import { Session } from "@opencode-ai/schema/session"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { Deferred, Effect, Fiber, Schema } from "effect"
+import { Effect, Schema } from "effect"
 
 const context = {
   sessionID: Session.ID.make("ses_execute"),
@@ -14,19 +14,6 @@ const context = {
   progress: () => Effect.void,
 }
 
-test("execute describes invariant Code Mode behavior", () => {
-  expect(ExecuteTool.create(new Map()).description).toBe(
-    [
-      "Run JavaScript to orchestrate tool calls and compose their results through `{ code }` in a confined Code Mode runtime.",
-      "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
-      "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
-      'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
-      "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
-      "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`.",
-    ].join("\n"),
-  )
-})
-
 test("canonical execution distinguishes declared, model-only, and raw schema outputs", async () => {
   const declared = Tool.make({
     description: "Declared",
@@ -144,46 +131,3 @@ test("execute supports callable namespace tools", async () => {
   })
   expect(result.content).toEqual([{ type: "text", text: '[\n  "admin",\n  "created"\n]' }])
 })
-
-test("execute marks every admitted child call failed when interrupted", async () => {
-  const child = Tool.make({
-    description: "Wait forever",
-    input: Schema.Struct({ id: Schema.Number }),
-    output: Schema.String,
-    execute: () => Effect.never,
-  })
-  const execute = ExecuteTool.create(new Map([["wait", { tool: child, name: "wait", permission: "wait" }]]))
-  const updates: Tool.Metadata[] = []
-
-  await Effect.runPromise(
-    Effect.gen(function* () {
-      const started = yield* Deferred.make<void>()
-      const fiber = yield* Tool.execute(
-        execute,
-        { code: "return await Promise.all([tools.wait({ id: 1 }), tools.wait({ id: 2 })])" },
-        {
-          ...context,
-          progress: (update) =>
-            Effect.gen(function* () {
-              updates.push(update)
-              if (updates.length > 1) return
-              yield* Deferred.succeed(started, undefined)
-              yield* Effect.never
-            }),
-        },
-      ).pipe(Effect.forkChild)
-      yield* Deferred.await(started)
-      yield* Effect.yieldNow
-      yield* Effect.yieldNow
-      yield* Fiber.interrupt(fiber)
-    }),
-  )
-
-  expect(updates[0]).toEqual({ toolCalls: [{ tool: "wait", status: "running", input: { id: 1 } }] })
-  expect(updates.at(-1)).toEqual({
-    toolCalls: [
-      { tool: "wait", status: "error", input: { id: 1 } },
-      { tool: "wait", status: "error", input: { id: 2 } },
-    ],
-  })
-})

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

@@ -181,7 +181,7 @@ describe("PatchTool", () => {
           Effect.andThen(
             withTool(tmp.path, (registry) =>
               Effect.gen(function* () {
-                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["patch", "execute"])
+                expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["patch"])
                 const settled = yield* executeTool(
                   registry,
                   call(

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

@@ -97,11 +97,7 @@ describe("QuestionTool", () => {
       deny = true
       const registry = yield* ToolRegistry.Service
 
-      expect(
-        (yield* toolDefinitions(registry, [{ action: "question", resource: "*", effect: "deny" }])).map(
-          (tool) => tool.name,
-        ),
-      ).toEqual(["execute"])
+      expect(yield* toolDefinitions(registry, [{ action: "question", resource: "*", effect: "deny" }])).toEqual([])
       expect(
         yield* executeTool(registry, {
           sessionID,
@@ -146,7 +142,7 @@ describe("QuestionTool", () => {
         },
       ]
 
-      expect((yield* toolDefinitions(registry)).map((definition) => definition.name)).toEqual(["question", "execute"])
+      expect((yield* toolDefinitions(registry)).map((definition) => definition.name)).toEqual(["question"])
       expect(
         yield* executeTool(registry, {
           sessionID,

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

@@ -197,12 +197,8 @@ describe("ReadTool", () => {
     Effect.gen(function* () {
       const registry = yield* ToolRegistry.Service
 
-      expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["read", "execute"])
-      expect(
-        (yield* toolDefinitions(registry, [{ action: "read", resource: "*", effect: "deny" }])).map(
-          (tool) => tool.name,
-        ),
-      ).toEqual(["execute"])
+      expect(yield* toolDefinitions(registry)).toMatchObject([{ name: "read" }])
+      expect(yield* toolDefinitions(registry, [{ action: "read", resource: "*", effect: "deny" }])).toEqual([])
       const execution = yield* executeTool(registry, {
         sessionID,
         ...toolIdentity,

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

@@ -8,7 +8,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { FileSystem } from "@opencode-ai/core/filesystem"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "@opencode-ai/core/location"
-import { LocationMutation } from "@opencode-ai/core/location-mutation"
 import { PermissionV2 } from "@opencode-ai/core/permission"
 import { Ripgrep } from "@opencode-ai/core/ripgrep"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -25,27 +24,27 @@ import { executeTool, registerToolPlugin, toolIdentity } from "./lib/tool"
 const globToolNode = makeLocationNode({
   name: "test/glob-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(GlobTool.Plugin)),
-  deps: [
-    ToolRegistry.toolsNode,
-    FSUtil.node,
-    Ripgrep.node,
-    Location.node,
-    LocationMutation.node,
-    PermissionV2.node,
-  ],
+  deps: [ToolRegistry.toolsNode, FSUtil.node, Ripgrep.node, Location.node, PermissionV2.node],
 })
 const grepToolNode = makeLocationNode({
   name: "test/grep-tool-plugin",
   layer: Layer.effectDiscard(registerToolPlugin(GrepTool.Plugin)),
   deps: [ToolRegistry.toolsNode, FSUtil.node, Ripgrep.node, Location.node, PermissionV2.node],
 })
+const permission = Layer.succeed(
+  PermissionV2.Service,
+  PermissionV2.Service.of({
+    assert: () => Effect.void,
+    ask: () => Effect.die("unused"),
+    reply: () => Effect.die("unused"),
+    get: () => Effect.die("unused"),
+    forSession: () => Effect.die("unused"),
+    list: () => Effect.die("unused"),
+  }),
+)
 const sessionID = SessionV2.ID.make("ses_search_tool_test")
 
-const withTools = <A, E, R>(
-  directory: string,
-  body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>,
-  assertions?: PermissionV2.AssertInput[],
-) =>
+const withTools = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) =>
   Effect.gen(function* () {
     return yield* body(yield* ToolRegistry.Service)
   }).pipe(
@@ -55,23 +54,7 @@ const withTools = <A, E, R>(
           Location.node,
           Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
         ],
-        [
-          PermissionV2.node,
-          Layer.succeed(
-            PermissionV2.Service,
-            PermissionV2.Service.of({
-              assert: (input) =>
-                Effect.sync(() => {
-                  assertions?.push(input)
-                }),
-              ask: () => Effect.die("unused"),
-              reply: () => Effect.die("unused"),
-              get: () => Effect.die("unused"),
-              forSession: () => Effect.die("unused"),
-              list: () => Effect.die("unused"),
-            }),
-          ),
-        ],
+        [PermissionV2.node, permission],
         [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
       ]),
     ),
@@ -104,7 +87,7 @@ describe("search tools", () => {
               const grep = yield* executeTool(registry, call("grep", { pattern: "needle" }))
 
               expect(glob.metadata).toEqual({ count: FileSystem.DEFAULT_SEARCH_LIMIT, truncated: true })
-              expect(grep.metadata).toEqual({ matches: FileSystem.DEFAULT_SEARCH_LIMIT, truncated: true })
+              expect(grep.metadata).toEqual({ matches: FileSystem.DEFAULT_SEARCH_LIMIT })
               expect(glob.content).toHaveLength(1)
               expect(grep.content).toHaveLength(1)
               const globText = glob.content?.[0]?.type === "text" ? glob.content[0].text : ""
@@ -114,9 +97,6 @@ describe("search tools", () => {
                 `(Results are truncated: showing first ${FileSystem.DEFAULT_SEARCH_LIMIT} results. Consider using a more specific path or pattern.)`,
               )
               expect(grepText).toStartWith(`Found ${FileSystem.DEFAULT_SEARCH_LIMIT} matches\n`)
-              expect(grepText).toEndWith(
-                `(Results are truncated: showing first ${FileSystem.DEFAULT_SEARCH_LIMIT} results. Consider using a more specific path or pattern.)`,
-              )
             }),
           )
         }),
@@ -124,65 +104,6 @@ describe("search tools", () => {
     ),
   )
 
-  it.live("rejects an empty grep pattern", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        withTools(tmp.path, (registry) =>
-          Effect.gen(function* () {
-            expect(yield* executeTool(registry, call("grep", { pattern: "" }))).toEqual({
-              status: "error",
-              error: {
-                type: "tool.execution",
-                message: 'Invalid tool input: Pattern must not be empty\n  at ["pattern"]',
-              },
-            })
-          }),
-        ),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
-  it.live("handles explicit grep file and directory paths", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.promise(() =>
-          Promise.all([
-            fs.writeFile(path.join(tmp.path, "target.txt"), "needle\n"),
-            fs.writeFile(path.join(tmp.path, "other.txt"), "needle\n"),
-          ]),
-        ).pipe(
-          Effect.andThen(
-            withTools(tmp.path, (registry) =>
-              Effect.gen(function* () {
-                const file = yield* executeTool(registry, call("grep", { path: "target.txt", pattern: "needle" }))
-                expect(file).toMatchObject({
-                  status: "completed",
-                  output: [{ entry: { path: "target.txt" }, line: 1, text: "needle\n" }],
-                  metadata: { matches: 1, truncated: false },
-                })
-
-                const directory = yield* executeTool(registry, call("grep", { path: ".", pattern: "needle" }))
-                expect(directory).toMatchObject({
-                  status: "completed",
-                  metadata: { matches: 2, truncated: false },
-                })
-                if (directory.status !== "completed") return
-                expect(directory.output).toEqual(
-                  expect.arrayContaining([
-                    expect.objectContaining({ entry: expect.objectContaining({ path: "target.txt" }) }),
-                    expect.objectContaining({ entry: expect.objectContaining({ path: "other.txt" }) }),
-                  ]),
-                )
-              }),
-            ),
-          ),
-        ),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
   for (const name of ["glob", "grep"] as const) {
     it.live(`${name} reports a missing search path`, () =>
       Effect.acquireUseRelease(
@@ -204,94 +125,4 @@ describe("search tools", () => {
       ),
     )
   }
-
-  it.live("reports a file used as the glob search path", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) =>
-        Effect.promise(() => fs.writeFile(path.join(tmp.path, "file.txt"), "content\n")).pipe(
-          Effect.andThen(
-            withTools(tmp.path, (registry) =>
-              executeTool(registry, call("glob", { path: "file.txt", pattern: "*" })),
-            ),
-          ),
-          Effect.tap((result) =>
-            Effect.sync(() => {
-              expect(result).toEqual({
-                status: "error",
-                error: { type: "tool.execution", message: "Search path is not a directory: file.txt" },
-              })
-            }),
-          ),
-        ),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
-  it.live("requires external_directory approval for an explicit external glob path", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      ([active, outside]) => {
-        const assertions: PermissionV2.AssertInput[] = []
-        return Effect.promise(() => fs.writeFile(path.join(outside.path, "outside.txt"), "outside\n")).pipe(
-          Effect.andThen(
-            withTools(
-              active.path,
-              (registry) => executeTool(registry, call("glob", { path: outside.path, pattern: "*.txt" })),
-              assertions,
-            ),
-          ),
-          Effect.tap((result) =>
-            Effect.sync(() => {
-              expect(result.status).toBe("completed")
-              expect(assertions.map((input) => input.action)).toEqual(["external_directory", "glob"])
-              expect(assertions[0]?.resources).toEqual([
-                path.join(outside.path, "*").replaceAll("\\", "/"),
-              ])
-            }),
-          ),
-        )
-      },
-      ([active, outside]) =>
-        Effect.promise(() =>
-          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
-        ),
-    ),
-  )
-
-  it.live("globs through an in-location external symlink without external approval", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      ([active, outside]) => {
-        if (process.platform === "win32") return Effect.void
-        const assertions: PermissionV2.AssertInput[] = []
-        return Effect.promise(async () => {
-          await fs.writeFile(path.join(outside.path, "outside.txt"), "outside\n")
-          await fs.symlink(outside.path, path.join(active.path, "linked"))
-        }).pipe(
-          Effect.andThen(
-            withTools(
-              active.path,
-              (registry) => executeTool(registry, call("glob", { path: "linked", pattern: "*.txt" })),
-              assertions,
-            ),
-          ),
-          Effect.tap((result) =>
-            Effect.sync(() => {
-              expect(result.status).toBe("completed")
-              expect(assertions.map((input) => input.action)).toEqual(["glob"])
-              expect(result).toMatchObject({
-                output: [{ path: path.join("linked", "outside.txt"), type: "file" }],
-                content: [{ type: "text", text: path.join(active.path, "linked", "outside.txt") }],
-              })
-            }),
-          ),
-        )
-      },
-      ([active, outside]) =>
-        Effect.promise(() =>
-          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
-        ),
-    ),
-  )
 })

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

@@ -92,7 +92,7 @@ describe("WebFetchTool registration", () => {
       const registry = yield* ToolRegistry.Service
       const url = "http://example.com/public"
 
-      expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["webfetch", "execute"])
+      expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["webfetch"])
       expect(yield* executeTool(registry, call({ url, format: "text", timeout: 4 }))).toEqual({
         status: "completed",
         output: { url, contentType: "text/plain", format: "text", output: "hello" },

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

@@ -1,11 +1,10 @@
-import { beforeEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { beforeEach, describe, expect, test } from "bun:test"
+import { Effect, Layer, Schema } from "effect"
+import { HttpClient, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { LayerNodePlatform } from "@opencode-ai/util/effect/app-node-platform"
 import { PermissionV2 } from "@opencode-ai/core/permission"
-import { Form } from "@opencode-ai/core/form"
-import { KV } from "@opencode-ai/core/kv"
-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"
@@ -15,36 +14,93 @@ import { Image } from "@opencode-ai/core/image"
 import { testEffect } from "./lib/effect"
 import { imagePassthrough } from "./lib/image"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
-import { webSearchHost } from "./plugin/host"
 
 const webSearchToolNode = makeLocationNode({
   name: "test/websearch-tool-plugin",
-  layer: Layer.effectDiscard(
-    Effect.gen(function* () {
-      const websearch = yield* WebSearch.Service
-      yield* registerToolPlugin(WebSearchTool.Plugin, { websearch: webSearchHost(websearch) })
-    }),
-  ),
-  deps: [ToolRegistry.toolsNode, PermissionV2.node, WebSearch.node, Form.node, KV.node],
+  layer: Layer.effectDiscard(registerToolPlugin(WebSearchTool.Plugin)),
+  deps: [ToolRegistry.toolsNode, PermissionV2.node, LayerNodePlatform.httpClient, WebSearchTool.configNode],
 })
 
 const sessionID = SessionV2.ID.make("ses_websearch_test")
-const assertions: PermissionV2.AssertInput[] = []
-const queries: WebSearch.Input[] = []
-let result = new WebSearch.Response({
-  providerID: WebSearch.ID.make("exa"),
-  results: [{ url: "https://example.com", title: "Search results", content: "search results", time: {} }],
-})
+const payload = (text: string) =>
+  JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    result: { content: [{ type: "text", text }] },
+  })
 
-beforeEach(() => {
-  assertions.length = 0
-  queries.length = 0
-  result = new WebSearch.Response({
-    providerID: WebSearch.ID.make("exa"),
-    results: [{ url: "https://example.com", title: "Search results", content: "search results", time: {} }],
+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 }
+
+beforeEach(() => {
+  responseBody = payload("search results")
+  makeResponse = () => new Response(responseBody, { status: 200 })
+})
+
+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({
@@ -56,48 +112,33 @@ const permission = Layer.succeed(
     list: () => Effect.die("unused"),
   }),
 )
-const websearch = Layer.succeed(
-  WebSearch.Service,
-  WebSearch.Service.of({
-    transform: () => Effect.die("unused"),
-    reload: () => Effect.die("unused"),
-    providers: () => Effect.succeed([]),
-    default: () => Effect.succeed(undefined),
-    query: (input) =>
-      Effect.sync(() => {
-        queries.push(input)
-        return result
-      }),
-  }),
-)
-const form = Layer.succeed(
-  Form.Service,
-  Form.Service.of({
-    create: () => Effect.die("unused"),
-    ask: () => Effect.die("unused"),
-    get: () => Effect.die("unused"),
-    list: () => Effect.die("unused"),
-    state: () => Effect.die("unused"),
-    reply: () => Effect.die("unused"),
-    cancel: () => Effect.die("unused"),
-  }),
-)
-const kv = Layer.succeed(
-  KV.Service,
-  KV.Service.of({
-    get: () => Effect.succeed(undefined),
-    set: () => Effect.void,
-    remove: () => Effect.void,
+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 it = testEffect(
   AppNodeBuilder.build(
-    LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, WebSearch.node, webSearchToolNode]),
+    LayerNode.group([ToolRegistry.node, ToolRegistry.toolsNode, WebSearchTool.configNode, webSearchToolNode]),
     [
       [PermissionV2.node, permission],
-      [WebSearch.node, websearch],
-      [Form.node, form],
-      [KV.node, kv],
+      [LayerNodePlatform.httpClient, http],
+      [WebSearchTool.configNode, websearchConfig],
       [ToolOutputStore.node, ToolOutputStore.nodeWithoutConfig],
       [Image.node, imagePassthrough],
     ],
@@ -105,25 +146,35 @@ const it = testEffect(
 )
 
 describe("WebSearchTool registration", () => {
-  it.effect("asserts permission before delegating to WebSearch", () =>
+  it.effect("registers websearch, asserts query permission, and calls Exa", () =>
     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", "execute"])
+      expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["websearch"])
       expect(
         yield* executeTool(registry, {
           sessionID,
           ...toolIdentity,
           call: {
             type: "tool-call",
-            id: "call-search",
+            id: "call-exa",
             name: "websearch",
-            input: { query: "effect typescript" },
+            input: {
+              query: "effect typescript",
+              numResults: 3,
+              livecrawl: "preferred",
+              type: "fast",
+              contextMaxCharacters: 2500,
+            },
           },
         }),
       ).toMatchObject({
         status: "completed",
-        content: [{ type: "text", text: "## [Search results](https://example.com)\n\nsearch results" }],
+        content: [{ type: "text", text: "exa results" }],
       })
       expect(assertions).toMatchObject([
         {
@@ -131,65 +182,103 @@ describe("WebSearchTool registration", () => {
           action: "websearch",
           resources: ["effect typescript"],
           save: ["*"],
-          metadata: { query: "effect typescript" },
+          metadata: {
+            query: "effect typescript",
+            numResults: 3,
+            livecrawl: "preferred",
+            type: "fast",
+            contextMaxCharacters: 2500,
+            provider: "exa",
+          },
         },
       ])
-      expect(queries).toEqual([
+      expect(requests).toEqual([
         {
-          query: "effect typescript",
+          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,
+              },
+            },
+          },
         },
       ])
     }),
   )
 
-  it.effect("keeps normalized results in structured output", () =>
+  it.effect("calls Parallel with session ID and keeps bearer credentials out of output", () =>
     Effect.gen(function* () {
-      result = new WebSearch.Response({
-        providerID: WebSearch.ID.make("parallel"),
-        results: [
-          {
-            url: "https://effect.website",
-            title: "Effect",
-            content: "parallel results",
-            time: { published: Date.parse("2026-07-25T00:00:00.000Z") },
-          },
-        ],
-      })
+      requests.length = 0
+      assertions.length = 0
+      responseBody = payload("parallel results")
+      config = { provider: "parallel", enableExa: false, enableParallel: false, parallelApiKey: "parallel-secret" }
       const registry = yield* ToolRegistry.Service
 
-      expect(
-        yield* executeTool(registry, {
-          sessionID,
-          ...toolIdentity,
-          call: { type: "tool-call", id: "call-parallel", name: "websearch", input: { query: "effect layers" } },
-        }),
-      ).toEqual({
-        status: "completed",
-        output: {
-          provider: "parallel",
-          results: [
-            {
-              url: "https://effect.website",
-              title: "Effect",
-              content: "parallel results",
-              time: { published: Date.parse("2026-07-25T00:00:00.000Z") },
-            },
-          ],
-        },
-        content: [
-          {
-            type: "text",
-            text: "## [Effect](https://effect.website)\nPublished: 2026-07-25T00:00:00.000Z\n\nparallel results",
+      const settled = yield* executeTool(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({
+        status: "completed",
+        output: { provider: "parallel", text: "parallel results" },
+        content: [{ type: "text", text: "parallel results" }],
         metadata: { provider: "parallel" },
       })
+      expect(JSON.stringify(settled)).not.toContain("parallel-secret")
     }),
   )
 
-  it.effect("uses the concise no-results fallback", () =>
+  it.effect("keeps an Exa credential in the transport URL and out of model output", () =>
     Effect.gen(function* () {
-      result = new WebSearch.Response({ providerID: WebSearch.ID.make("exa"), results: [] })
+      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* executeTool(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 }
       const registry = yield* ToolRegistry.Service
 
       expect(
@@ -204,4 +293,44 @@ describe("WebSearchTool registration", () => {
       })
     }),
   )
+
+  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" } },
+        }),
+        // toSessionError unwraps the "Unable to search the web for <query>" ToolFailure
+        // to its byte-limit cause message.
+      ).toEqual({
+        status: "error",
+        error: { type: "unknown", message: expect.stringContaining("response exceeded") },
+      })
+      expect(chunksRead).toBeLessThan(10)
+      expect(cancelled).toBe(true)
+    }),
+  )
 })

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

@@ -118,7 +118,7 @@ describe("WriteTool", () => {
         reset()
         return withTool(tmp.path, (registry) =>
           Effect.gen(function* () {
-            expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["write", "execute"])
+            expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["write"])
             const settled = yield* executeTool(registry, call({ path: "src/new.txt", content: "created" }))
             expect(settled).toEqual({
               status: "completed",

packages/core/test/websearch.test.ts

@@ -1,129 +0,0 @@
-import { describe, expect } from "bun:test"
-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 { EventV2 } from "@opencode-ai/core/event"
-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, EventV2.node, KV.node])))
-
-const register = (id: string) =>
-  Effect.gen(function* () {
-    const websearch = yield* WebSearch.Service
-    const providerID = WebSearch.ID.make(id)
-    const calls: WebSearch.ProviderInput[] = []
-    yield* websearch.transform((draft) => {
-      draft.add({
-        id: providerID,
-        name: id.toUpperCase(),
-        execute: (input) =>
-          Effect.sync(() => {
-            calls.push(input)
-            return [
-              {
-                url: `https://${id}.example.com`,
-                title: input.query,
-                content: `${id}: ${input.query}`,
-                time: {},
-              },
-            ]
-          }),
-      })
-    })
-    return { providerID, calls }
-  })
-
-describe("WebSearch", () => {
-  it.effect("executes an explicit provider without changing the default", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      const parallel = yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-
-      expect(yield* websearch.query({ query: "effect", providerID: parallel.providerID })).toEqual(
-        new WebSearch.Response({
-          providerID: parallel.providerID,
-          results: [
-            {
-              url: "https://parallel.example.com",
-              title: "effect",
-              content: "parallel: effect",
-              time: {},
-            },
-          ],
-        }),
-      )
-      expect((yield* websearch.query({ query: "default" }).pipe(Effect.flip))._tag).toBe("WebSearch.ProviderRequired")
-      expect(parallel.calls).toEqual([{ query: "effect" }])
-    }),
-  )
-
-  it.effect("requires a provider when no default is set", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-
-      expect((yield* websearch.query({ query: "layers" }).pipe(Effect.flip))._tag).toBe("WebSearch.ProviderRequired")
-    }),
-  )
-
-  it.effect("uses the default set by a transform", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      const parallel = yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-      yield* websearch.transform((draft) => draft.default.set(parallel.providerID))
-
-      expect((yield* websearch.query({ query: "configured" })).providerID).toBe(parallel.providerID)
-    }),
-  )
-
-  it.effect("uses the provider stored in KV", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      const parallel = yield* register("parallel")
-      const websearch = yield* WebSearch.Service
-      const kv = yield* KV.Service
-      yield* kv.set("websearch:provider", parallel.providerID)
-
-      expect((yield* websearch.query({ query: "stored" })).providerID).toBe(parallel.providerID)
-      yield* kv.remove("websearch:provider")
-    }),
-  )
-
-  it.effect("fails when web search is explicitly disabled", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      const websearch = yield* WebSearch.Service
-      const kv = yield* KV.Service
-      yield* kv.set("websearch:provider", false)
-
-      expect((yield* websearch.query({ query: "disabled" }).pipe(Effect.flip))._tag).toBe("WebSearch.Disabled")
-      yield* kv.remove("websearch:provider")
-    }),
-  )
-
-  it.effect("falls back when the configured default is unavailable", () =>
-    Effect.gen(function* () {
-      yield* register("exa")
-      const websearch = yield* WebSearch.Service
-      yield* websearch.transform((draft) => draft.default.set(WebSearch.ID.make("missing")))
-
-      expect((yield* websearch.query({ query: "fallback" }).pipe(Effect.flip))._tag).toBe("WebSearch.ProviderRequired")
-    }),
-  )
-
-  it.effect("removes scoped provider registrations", () =>
-    Effect.gen(function* () {
-      const websearch = yield* WebSearch.Service
-      const scope = yield* Scope.fork(yield* Scope.Scope)
-      const provider = yield* register("temporary").pipe(Scope.provide(scope))
-      expect(yield* websearch.providers()).toContainEqual({ id: provider.providerID, name: "TEMPORARY" })
-      yield* Scope.close(scope, Exit.void)
-      expect(yield* websearch.providers()).not.toContainEqual({ id: provider.providerID, name: "TEMPORARY" })
-    }),
-  )
-})

packages/docs/AGENTS.md

@@ -0,0 +1,22 @@
+# V2 documentation guide
+
+## Structure
+
+- This directory is a standalone Mintlify site deployed from `packages/docs` on the `dev` branch.
+- Write documentation in MDX. Every page should have `title` and `description` frontmatter.
+- `docs.json` owns site configuration and navigation. Add, move, or remove its page entries whenever the corresponding MDX pages change.
+- Put static files in `assets/` and reference them with root-relative paths such as `/assets/example.svg`.
+- The API endpoint reference is generated by Mintlify from `openapi.json`; do not duplicate endpoint documentation as hand-written MDX.
+- Keep documentation aligned with the V2 packages. Do not use `packages/opencode` as the source of truth unless the task explicitly concerns V1.
+
+## Local development
+
+- At the start of documentation work, launch `bun dev` from `packages/docs` using the shell tool with `background: true`. Never run the dev server in a foreground shell call and do not poll the process; wait for the background completion notification.
+- Preview the site at `http://localhost:3333`. Mintlify does not expose a host option and binds the preview to all network interfaces. The server reloads changes to MDX and `docs.json` automatically.
+- Use the running preview to verify navigation, links, Mintlify components, code blocks, and desktop and mobile layout.
+
+## Validation
+
+- Run `bun validate` from `packages/docs` after making documentation or configuration changes.
+- Run `bun broken-links` from `packages/docs` when pages, navigation, headings, or links change.
+- Treat validation errors and broken internal links as blockers. Also verify external links relevant to the change when practical.