refactor(core): localize read tool input schema

.github/workflows/publish.yml

@@ -47,7 +47,7 @@ jobs:
       - uses: ./.github/actions/setup-bun
 
       - name: Deploy update service
-        if: github.ref_name == 'v2'
+        if: github.ref_name == 'v2' || github.ref_name == 'beta'
         working-directory: packages/updates
         run: bun run deploy
         env:

bun.lock

@@ -575,7 +575,6 @@
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/protocol": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
-        "@opencode-ai/util": "workspace:*",
         "@standard-schema/spec": "catalog:",
         "effect": "catalog:",
         "zod": "catalog:",
@@ -586,7 +585,6 @@
         "@opentui/solid": "catalog:",
         "@tsconfig/bun": "catalog:",
         "@tsconfig/node22": "catalog:",
-        "@types/bun": "catalog:",
         "@types/node": "catalog:",
         "@typescript/native-preview": "catalog:",
         "solid-js": "catalog:",
@@ -973,6 +971,7 @@
         "minimatch": "10.2.5",
         "npm-package-arg": "13.0.2",
         "pacote": "21.5.1",
+        "resolve.exports": "catalog:",
       },
       "devDependencies": {
         "@tsconfig/bun": "catalog:",
@@ -1046,7 +1045,6 @@
     "@pierre/trees@1.0.0-beta.4": "patches/@pierre%2Ftrees@1.0.0-beta.4.patch",
     "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
-    "ghostty-web@github:anomalyco/ghostty-web#83c0a07": "patches/ghostty-web@0.3.0.patch",
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
     "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
     "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
@@ -1125,6 +1123,7 @@
     "opentui-spinner": "0.0.7",
     "remeda": "2.26.0",
     "remend": "1.3.1",
+    "resolve.exports": "2.0.3",
     "semver": "7.7.4",
     "shiki": "4.4.3",
     "solid-js": "1.9.15",
@@ -5172,6 +5171,8 @@
 
     "resolve-pkg-maps": ["resolve-pkg-maps@1.0.0", "", {}, "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw=="],
 
+    "resolve.exports": ["resolve.exports@2.0.3", "", {}, "sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A=="],
+
     "responselike": ["responselike@2.0.1", "", { "dependencies": { "lowercase-keys": "^2.0.0" } }, "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw=="],
 
     "restructure": ["restructure@3.0.2", "", {}, "sha512-gSfoiOEA0VPE6Tukkrr7I0RBdE0s7H1eFCDBk05l1KIQT1UIKNc5JZy6jdyW6eYH3aR3g5b3PuL77rq0hvwtAw=="],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-I2sHU46Bdp1DmW/ygNKKxF6U53oNIeVeAS8TmMdtvzw=",
-    "aarch64-linux": "sha256-aQUEBmfHhaR/YdsRyw0u6hsEo0TEmXHBMyiGnOFRCeI=",
-    "aarch64-darwin": "sha256-40Y3HYSjs8S0M3SFNUrU8lMYaHy7vpmiW+7b6Y9pKzs=",
-    "x86_64-darwin": "sha256-7iGegI/1pXcR5W0UBX0wAWAga+F34fhj9lbAHotVwEo="
+    "x86_64-linux": "sha256-Vazzj75ji5YbLtX5X0q+IZvygGrfmEi3+PzJsAkaa3s=",
+    "aarch64-linux": "sha256-QFKzH7wlRcvYG4EHQgQ+++9zNQ+Mw5DVKembGiMjiCg=",
+    "aarch64-darwin": "sha256-WAYBBA2jLW95wM8Dgk77KsO3yS5efxQs9oBVAcdx8Gc=",
+    "x86_64-darwin": "sha256-c9P+VQvfdOu5ef6BnKXb3/IUo8pPFaYQv8B+ijofm1s="
   }
 }

package.json

@@ -27,6 +27,7 @@
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
     "prepare": "husky",
+    "reserve-packages": "bun script/reserve-package-names.ts",
     "random": "echo 'Random script'",
     "sso": "aws sso login --sso-session=opencode --no-browser",
     "test": "echo 'do not run tests from root' && exit 1"
@@ -92,6 +93,7 @@
       "@typescript/native-preview": "7.0.0-dev.20251207.1",
       "zod": "4.1.8",
       "remeda": "2.26.0",
+      "resolve.exports": "2.0.3",
       "sst": "4.13.1",
       "shiki": "4.4.3",
       "solid-list": "0.3.0",
@@ -177,7 +179,6 @@
     "@modelcontextprotocol/sdk@1.29.0": "patches/@modelcontextprotocol%2Fsdk@1.29.0.patch",
     "@tanstack/virtual-core@3.17.8": "patches/@tanstack%2Fvirtual-core@3.17.8.patch",
     "@ff-labs/fff-bun@0.10.5": "patches/@ff-labs%2Ffff-bun@0.10.5.patch",
-    "ghostty-web@github:anomalyco/ghostty-web#83c0a07": "patches/ghostty-web@0.3.0.patch",
     "vite@8.2.2": "patches/vite@8.2.2.patch"
   }
 }

packages/ai/README.md

@@ -241,115 +241,14 @@ Constructing `stream()` or `generate()` does not record a request, invoke a resp
 Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
 future reply.
 
-Generation responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
 supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
 it does not repair or truncate them.
 
-For explicit compaction, script a `CompactionResponse` through `push`, `always`, or `serve`. Its `replacement` contains the next context window, including retained user messages. The client returns that result and usage directly, with the same lazy request recording and gates. Generation and compaction reject fixtures for the wrong operation instead of converting between response shapes.
-
 The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
 over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
 `testLayer`.
 
-## Provider compaction
-
-Compaction is opt-in. The package supports automatic compaction in OpenAI/Azure Responses and Anthropic Messages (including Claude on Vertex), and explicit compaction calls in OpenAI/Azure/xAI Responses. Model and deployment support still depends on the provider. Bedrock compaction is deferred to a separate follow-up.
-
-This is different from prompt caching, server-side history storage, or truncation. Compaction returns provider-owned context that must be replayed to continue the conversation.
-
-### Explicit compaction
-
-`LLMClient.compact(request)` is the caller-controlled operation for OpenAI, Azure, and xAI Responses. It performs exactly one HTTP call to `/responses/compact`, using the selected route's endpoint, credentials, query, and HTTP middleware. It returns a `CompactionResponse` with `replacement: Message[]` and optional `usage`, not a normal generation response.
-
-Prefer this operation, where supported, when the application owns compaction policy and durable context updates.
-
-```ts
-const result = yield * LLMClient.compact(request)
-const next = LLMRequest.update(request, {
-  messages: result.replacement,
-})
-const response = yield * LLMClient.generate(next)
-```
-
-`replacement` replaces the complete input window. Do not append it to the original transcript or extract only the encrypted item: the provider may retain additional messages in its output. Retained user and assistant messages remain ordinary messages with typed text, media, or reasoning parts, in their original order. Provider-specific message IDs, status, and phase use `providerMetadata`, not a raw output array hidden in an assistant message. Unsupported returned item types fail explicitly.
-
-The selected model carries explicit-compaction capability through request construction and updates. Calls using unsupported routes fail type checking. When the model is selected dynamically, narrow the request with `LLMClient.canCompact(request)` before calling `LLMClient.compact`; a model or route switch does not inherit the old capability. Runtime validation still rejects unsupported calls from untyped consumers. Capability describes the route's API, not whether every model or custom deployment supports the operation.
-
-Generation-only body overlays such as `stream` and `store` are not sent to the compact endpoint. Supported compact controls such as service tier and prompt-cache settings preserve request defaults and HTTP-overlay precedence. Retained image and file detail settings survive serialization and replay.
-
-The input must still fit the model's context window. Explicit compaction is not an overflow-recovery operation. Anthropic does not expose this operation in this package; its in-band compaction remains available below. Compatible routes do not inherit an explicit compact endpoint simply because they use a Responses protocol.
-
-### Advanced: in-band compaction
-
-`providerOptions.contextManagement` lets the provider decide when to compact during an ordinary `generate` or `stream` call. This is an advanced option for callers that own persistence and recovery: persist the complete assistant message, including its checkpoint, before continuing. Enabling the option does not provide durable checkpoint storage, interruption recovery, or model-switch policy. Keep the prior context until a successful checkpoint has been persisted.
-
-Inside an `Effect.gen`, enable OpenAI compaction with typed provider options:
-
-```ts
-import { LLM, LLMClient, LLMRequest, Message } from "@opencode-ai/ai"
-import { OpenAI } from "@opencode-ai/ai/providers"
-
-const request = LLM.request({
-  model: OpenAI.configure({ apiKey }).responses("gpt-5.3-codex"),
-  messages,
-  providerOptions: {
-    contextManagement: [{ type: "compaction", compactThreshold: 200_000 }],
-  },
-})
-const response = yield * LLMClient.generate(request)
-const next = LLMRequest.update(request, {
-  messages: [...request.messages, response.message, Message.user("Continue")],
-})
-```
-
-`store: false` remains the default. Keep the entire `response.message`, not just `response.text`. Compaction events become ordered `CompactionPart`s alongside text and reasoning. The conversation contains everything needed to continue; there is no separate replay object or hidden provider transcript.
-
-A compaction part has `provider` and exactly one representation: `encrypted` for Responses, or `text` for Anthropic. Responses also preserves the optional checkpoint `id`. These fields survive message serialization without becoming visible assistant text. Sending a checkpoint to another provider or an incompatible API fails rather than silently losing context.
-
-```ts
-import { CompactionPart, ProviderID } from "@opencode-ai/ai"
-
-CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_123", encrypted: "..." })
-CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "Summary of the conversation..." })
-```
-
-For Anthropic, use:
-
-```ts
-providerOptions: {
-  contextManagement: {
-    edits: [{
-      type: "compact_20260112",
-      trigger: { type: "input_tokens", value: 150_000 },
-      pauseAfterCompaction: true,
-      instructions: "Summarize the task and decisions. Do not call tools while summarizing.",
-    }],
-  },
-}
-```
-
-- The trigger is optional (provider default: 150,000 tokens), with a minimum of 50,000.
-- Custom instructions replace Anthropic's default summarization instructions.
-- The route adds `compact-2026-01-12` to existing beta headers, including when replaying a checkpoint without enabling new compactions.
-- A pause is exposed as `response.finishReason.raw === "compaction"`. It occurs only if the threshold triggers compaction: `pauseAfterCompaction` does not mean "compact now". The caller explicitly issues the next request; the package never automatically resumes.
-- Anthropic can return a compaction block with `content: null` when summarization fails. This becomes a compaction part with `text: null`, which is **not** a successful replacement for prior history. The package never prunes history automatically.
-- `Usage` totals include all reported Anthropic `usage.iterations`, including compaction. `contextTokens` separately reports the final message iteration's inclusive input size, when available. A compaction-only pause does not report a post-compaction context size. Raw iteration usage remains in `providerMetadata`.
-
-### Ownership and verification
-
-The AI package transports options and typed conversation parts. It does not schedule compaction, persist Session checkpoints, select history, switch providers, or replace Core's existing local compaction policy. Native compaction is not enabled for OpenCode Sessions by this feature; Session integration must persist these parts before enabling it. The AI SDK bridge rejects native compaction parts rather than dropping them. Provider-executed tool APIs and persistence changes are a separate follow-up.
-
-Tests cover serialized round trips, real local HTTP plus a tool loop, WebSocket recovery, provider errors, malformed blocks, and usage accounting. Live provider tests are gated by `RECORD=true` and the relevant API keys:
-
-```sh
-# Run from packages/ai. Only records the selected new cassette group.
-RECORD=true RECORDED_PREFIX=openai-compaction bun test test/provider/compaction.recorded.test.ts
-RECORD=true RECORDED_PREFIX=xai-compaction bun test test/provider/compaction.recorded.test.ts
-RECORD=true RECORDED_PREFIX=anthropic-compaction bun test test/provider/compaction.recorded.test.ts
-```
-
-Provider references: [OpenAI](https://developers.openai.com/api/docs/guides/compaction), [Azure](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/responses#server-side-compaction), [Anthropic](https://platform.claude.com/docs/en/build-with-claude/compaction), [xAI](https://docs.x.ai/developers/advanced-api-usage/context-compaction).
-
 ## Caching
 
 Prompt caching is **on by default**. Every `LLMRequest` resolves to `cache: "auto"` unless the caller opts out with `cache: "none"`. Each protocol translates `CacheHint`s to its wire format (`cache_control` on Anthropic, `cachePoint` on Bedrock; OpenAI and Gemini do implicit caching server-side and don't need inline markers — auto is a no-op there).

packages/ai/src/cache-policy.ts

@@ -11,7 +11,7 @@
 // Manual `cache: CacheHint` placements on individual parts are preserved and
 // count against the four-breakpoint budget; auto only fills remaining slots.
 import { CacheHint, type CachePolicy, type CachePolicyObject } from "./schema/options.js"
-import { LLMRequest, Message, ToolDefinition, type ContentPart, type ToolEntry } from "./schema/messages.js"
+import { LLMRequest, Message, ToolDefinition, type ContentPart } from "./schema/messages.js"
 
 const AUTO: CachePolicyObject = {
   tools: true,
@@ -50,24 +50,18 @@ interface Budget {
   remaining: number
 }
 
-const markLastTool = (tools: ReadonlyArray<ToolEntry>, hint: CacheHint, budget: Budget): ReadonlyArray<ToolEntry> => {
-  const target = tools.at(-1)
-  if (target === undefined) return tools
-  if (target.type === "namespace") {
-    const nested = markLastTool(target.tools, hint, budget)
-    return nested === target.tools ? tools : [...tools.slice(0, -1), { ...target, tools: nested }]
-  }
-  if (target.cache || budget.remaining === 0) return tools
+const markLastTool = (
+  tools: ReadonlyArray<ToolDefinition>,
+  hint: CacheHint,
+  budget: Budget,
+): 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
-  return [...tools.slice(0, -1), new ToolDefinition({ ...target, cache: hint })]
+  return tools.map((tool, i) => (i === last ? new ToolDefinition({ ...tool, cache: hint }) : tool))
 }
 
-const countToolHints = (tools: ReadonlyArray<ToolEntry>): number =>
-  tools.reduce(
-    (count, tool) => count + (tool.type === "tool" ? (tool.cache === undefined ? 0 : 1) : countToolHints(tool.tools)),
-    0,
-  )
-
 const markSystemBoundaries = (system: LLMRequest["system"], hint: CacheHint, budget: Budget): LLMRequest["system"] => {
   if (system.length === 0) return system
   let changed = false
@@ -128,7 +122,7 @@ const markMessages = (
 }
 
 const countHints = (request: LLMRequest) =>
-  countToolHints(request.tools) +
+  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) =>

packages/ai/src/llm.ts

@@ -12,10 +12,9 @@ import {
   LanguageModel,
   SystemPart,
   ToolChoice,
-  ToolEntry,
+  ToolDefinition,
   type ContentPart,
   type LanguageModelProviderOptions,
-  type ToolEntryInput,
 } from "./schema/index.js"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool.js"
 
@@ -28,7 +27,7 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
   readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
   readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
   readonly messages?: ReadonlyArray<Message | Message.Input>
-  readonly tools?: ReadonlyArray<ToolEntryInput>
+  readonly tools?: ReadonlyArray<ToolDefinition.Input>
   readonly toolChoice?: ToolChoice.Input
   readonly generation?: GenerationOptions.Input
   readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>
@@ -57,7 +56,7 @@ export const request = <const SelectedLanguageModel extends LanguageModel>(
     ...rest,
     system: SystemPart.content(requestSystem),
     messages: [...(messages?.map(Message.make) ?? []), ...(prompt === undefined ? [] : [Message.user(prompt)])],
-    tools: tools?.map(ToolEntry.make) ?? [],
+    tools: tools?.map(ToolDefinition.make) ?? [],
     toolChoice: requestToolChoice ? ToolChoice.make(requestToolChoice) : undefined,
     generation: requestGeneration === undefined ? undefined : GenerationOptions.make(requestGeneration),
     providerOptions: requestProviderOptions,

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

@@ -6,12 +6,8 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
-import { Headers } from "effect/unstable/http"
-import { HttpTransport } from "../route/transport/index.js"
 import {
   AIError,
-  HttpOptions,
-  LLMRequest,
   LLMEvent,
   mergeJsonRecords,
   Usage,
@@ -19,6 +15,7 @@ import {
   type FinishReasonDetails,
   type FinishReason,
   type JsonSchema,
+  type LLMRequest,
   type MediaPart,
   type ProviderMetadata,
   type ToolCallPart,
@@ -64,8 +61,6 @@ export type ThinkingInput =
     ))
 
 export interface OptionsInput {
-  /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
-  readonly contextManagement?: ContextManagement
   readonly [key: string]: unknown
   readonly thinking?: ThinkingInput
   readonly effort?: string
@@ -94,23 +89,6 @@ export interface OptionsInput {
 
 export type ProviderOptionsInput = OptionsInput
 
-export const ContextManagement = Schema.Struct({
-  edits: Schema.Array(
-    Schema.Struct({
-      type: Schema.Literal("compact_20260112"),
-      trigger: Schema.optional(
-        Schema.Struct({
-          type: Schema.Literal("input_tokens"),
-          value: Schema.Int.check(Schema.isGreaterThanOrEqualTo(50000)),
-        }),
-      ),
-      pauseAfterCompaction: Schema.optional(Schema.Boolean),
-      instructions: Schema.optional(Schema.String),
-    }),
-  ),
-})
-export type ContextManagement = typeof ContextManagement.Type
-
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -258,12 +236,7 @@ const AnthropicUserBlock = Schema.Union([
   AnthropicToolResultBlock,
 ])
 type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
-const AnthropicCompactionBlock = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  content: Schema.NullOr(Schema.String),
-})
 const AnthropicAssistantBlock = Schema.Union([
-  AnthropicCompactionBlock,
   AnthropicTextBlock,
   AnthropicThinkingBlock,
   AnthropicRedactedThinkingBlock,
@@ -339,18 +312,6 @@ const AnthropicContainer = Schema.Union([
 ])
 
 const AnthropicBodyFields = {
-  context_management: Schema.optional(
-    Schema.Struct({
-      edits: Schema.Array(
-        Schema.Struct({
-          type: Schema.Literal("compact_20260112"),
-          trigger: ContextManagement.fields.edits.value.fields.trigger,
-          pause_after_compaction: Schema.optional(Schema.Boolean),
-          instructions: Schema.optional(Schema.String),
-        }),
-      ),
-    }),
-  ),
   model: Schema.String,
   system: optionalArray(AnthropicTextBlock),
   messages: Schema.Array(AnthropicMessage),
@@ -374,7 +335,7 @@ const AnthropicBodyFields = {
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields)
 export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesBody>
 
-const AnthropicIterationUsage = Schema.StructWithRest(
+const AnthropicUsage = Schema.StructWithRest(
   Schema.Struct({
     input_tokens: optionalNull(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
@@ -393,13 +354,6 @@ const AnthropicIterationUsage = Schema.StructWithRest(
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
-const AnthropicUsage = Schema.StructWithRest(
-  Schema.Struct({
-    ...AnthropicIterationUsage.schema.fields,
-    iterations: Schema.optional(Schema.Array(AnthropicIterationUsage)),
-  }),
-  [JsonObject],
-)
 type AnthropicUsage = Schema.Schema.Type<typeof AnthropicUsage>
 
 const AnthropicStreamBlock = Schema.Struct({
@@ -423,7 +377,6 @@ type AnthropicStreamBlock = Schema.Schema.Type<typeof AnthropicStreamBlock>
 const decodeAnthropicStreamBlock = Schema.decodeUnknownOption(AnthropicStreamBlock)
 
 const AnthropicStreamDelta = Schema.Struct({
-  content: optionalNull(Schema.String),
   type: Schema.optional(Schema.String),
   text: Schema.optional(Schema.String),
   thinking: Schema.optional(Schema.String),
@@ -453,8 +406,6 @@ const AnthropicEvent = Schema.Struct({
 type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 
 interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly compactions: Readonly<Record<number, string | null>>
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -897,12 +848,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
     if (message.role === "assistant") {
       const content: AnthropicAssistantBlock[] = []
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          if (part.provider !== request.model.provider || part.text === undefined)
-            return yield* invalid("Compaction state must be replayed to its originating provider and API")
-          content.push({ type: "compaction", content: part.text })
-          continue
-        }
         if (part.type === "text") {
           if (part.text.trim().length === 0) continue
           content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
@@ -1058,20 +1003,16 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   // Allocate the 4-breakpoint budget in invalidation order: tools → system →
   // messages. Tools live highest in the cache hierarchy, so when callers
   // over-mark we keep their tool hints and shed the message-tail ones first.
   const breakpoints = Cache.newBreakpoints(ANTHROPIC_BREAKPOINT_CAP)
-  const flattened = ProviderShared.flattenToolRequest(request)
   const tools =
-    flattened.tools.length === 0
+    request.tools.length === 0
       ? undefined
-      : flattened.tools.map((tool) =>
+      : request.tools.map((tool) =>
           lowerTool(
             breakpoints,
             tool,
@@ -1089,14 +1030,14 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
           text: part.text,
           cache_control: cacheControl(breakpoints, part.cache),
         }))
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Anthropic Messages: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${ANTHROPIC_BREAKPOINT_CAP} per request.`,
     )
   }
   const options = yield* resolveOptions(request)
-  const body = {
+  return {
     model: request.model.id,
     system,
     messages,
@@ -1117,18 +1058,6 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     metadata: options.metadata,
     service_tier: options.service_tier,
   }
-  if (!management) return body
-  return {
-    ...body,
-    context_management: {
-      edits: management.edits.map((edit) => ({
-        type: edit.type,
-        trigger: edit.trigger,
-        pause_after_compaction: edit.pauseAfterCompaction,
-        instructions: edit.instructions,
-      })),
-    },
-  }
 })
 
 // =============================================================================
@@ -1150,31 +1079,18 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // expose that subset through `output_tokens_details.thinking_tokens`.
 const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
   if (!usage) return undefined
-  const iterations = usage.iterations?.length ? usage.iterations : [usage]
-  const last = usage.iterations?.at(-1)
-  const nonCached = ProviderShared.sumTokens(...iterations.map((item) => item.input_tokens ?? undefined))
-  const cacheRead = ProviderShared.sumTokens(...iterations.map((item) => item.cache_read_input_tokens ?? undefined))
-  const cacheWrite = ProviderShared.sumTokens(
-    ...iterations.map((item) => item.cache_creation_input_tokens ?? undefined),
-  )
+  const nonCached = usage.input_tokens ?? undefined
+  const cacheRead = usage.cache_read_input_tokens ?? undefined
+  const cacheWrite = usage.cache_creation_input_tokens ?? undefined
   const inputTokens = ProviderShared.sumTokens(nonCached, cacheRead, cacheWrite)
-  const outputTokens = ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens))
   return new Usage({
     inputTokens,
-    outputTokens,
-    contextTokens:
-      last?.type === "message"
-        ? ProviderShared.sumTokens(
-            last.input_tokens ?? undefined,
-            last.cache_read_input_tokens ?? undefined,
-            last.cache_creation_input_tokens ?? undefined,
-          )
-        : undefined,
+    outputTokens: usage.output_tokens,
     nonCachedInputTokens: nonCached,
     cacheReadInputTokens: cacheRead,
     cacheWriteInputTokens: cacheWrite,
-    reasoningTokens: ProviderShared.sumTokens(...iterations.map((item) => item.output_tokens_details?.thinking_tokens)),
-    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
+    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
+    totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
     providerMetadata: { [providerMetadataKey]: usage },
   })
 }
@@ -1196,7 +1112,6 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerM
   return new Usage({
     inputTokens,
     outputTokens,
-    contextTokens: right.contextTokens ?? left.contextTokens,
     nonCachedInputTokens,
     cacheReadInputTokens,
     cacheWriteInputTokens,
@@ -1255,6 +1170,7 @@ const onContentBlockStart = (
   event: AnthropicEvent & { readonly content_block: AnthropicStreamBlock },
 ): StepResult => {
   const block = event.content_block
+  if (!block) return [state, NO_EVENTS]
 
   if (block.type === "tool_use" || block.type === "server_tool_use") {
     if (event.index === undefined || !block.id) return [state, NO_EVENTS]
@@ -1349,16 +1265,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
 ) {
   const delta = event.delta
 
-  if (delta.type === "compaction_delta") {
-    if (event.index === undefined || !(event.index in state.compactions) || delta.content === undefined)
-      return yield* ProviderShared.eventError(ADAPTER, "Compaction delta is missing its block or content")
-    return [
-      { ...state, compactions: { ...state.compactions, [event.index]: delta.content } },
-      NO_EVENTS,
-    ] satisfies StepResult
-  }
-
-  if (delta.type === "text_delta" && delta.text) {
+  if (delta?.type === "text_delta" && delta.text) {
     if (!state.lifecycle.text.has(`text-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1367,7 +1274,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "thinking_delta" && delta.thinking) {
+  if (delta?.type === "thinking_delta" && delta.thinking) {
     if (!state.lifecycle.reasoning.has(`reasoning-${event.index ?? 0}`)) return [state, NO_EVENTS] satisfies StepResult
     const events: LLMEvent[] = []
     return [
@@ -1379,7 +1286,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "signature_delta" && delta.signature) {
+  if (delta?.type === "signature_delta" && delta.signature) {
     const index = event.index ?? 0
     if (!state.lifecycle.reasoning.has(`reasoning-${index}`)) return [state, NO_EVENTS] satisfies StepResult
     return [
@@ -1391,7 +1298,7 @@ const onContentBlockDelta = Effect.fn("AnthropicMessages.onContentBlockDelta")(f
     ] satisfies StepResult
   }
 
-  if (delta.type === "input_json_delta" && event.index !== undefined) {
+  if (delta?.type === "input_json_delta" && event.index !== undefined) {
     if (!delta.partial_json) return [state, NO_EVENTS] satisfies StepResult
     if (!state.tools[event.index]) return [state, NO_EVENTS] satisfies StepResult
     const result = ToolStream.appendExisting(
@@ -1416,18 +1323,6 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
   event: AnthropicEvent,
 ) {
   if (event.index === undefined) return [state, NO_EVENTS] satisfies StepResult
-  if (event.index in state.compactions) {
-    const { [event.index]: content, ...compactions } = state.compactions
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        text: content,
-      }),
-    )
-    return [{ ...state, compactions, lifecycle }, events] satisfies StepResult
-  }
   const result = yield* ToolStream.finish(ADAPTER, state.tools, event.index)
   const events: LLMEvent[] = []
   const resultEvents = result.events ?? []
@@ -1479,8 +1374,6 @@ const onMessageDelta = (
 }
 
 const onMessageStop = Effect.fn("AnthropicMessages.onMessageStop")(function* (state: ParserState) {
-  if (Object.keys(state.compactions).length)
-    return yield* ProviderShared.eventError(ADAPTER, "Response ended with an incomplete compaction block")
   const result = yield* ToolStream.finishAll(ADAPTER, state.tools)
   const events: LLMEvent[] = []
   const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
@@ -1525,21 +1418,16 @@ const onError = (event: AnthropicEvent) => {
   )
 }
 
-const STREAM_BLOCK_TYPES = new Set([
-  "compaction",
-  "text",
-  "thinking",
-  "redacted_thinking",
-  "tool_use",
-  "server_tool_use",
-])
-const STREAM_DELTA_TYPES = new Set([
-  "compaction_delta",
-  "text_delta",
-  "thinking_delta",
-  "signature_delta",
-  "input_json_delta",
-])
+const isKnownStreamBlockType = (type: string) =>
+  type === "text" ||
+  type === "thinking" ||
+  type === "redacted_thinking" ||
+  type === "tool_use" ||
+  type === "server_tool_use" ||
+  isServerToolResultType(type)
+
+const isKnownStreamDeltaType = (type: string) =>
+  type === "text_delta" || type === "thinking_delta" || type === "signature_delta" || type === "input_json_delta"
 
 const invalidStreamEvent = (event: AnthropicEvent) =>
   Effect.fail(
@@ -1568,16 +1456,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   if (event.type === "content_block_start") {
     if (!ProviderShared.isRecord(event.content_block) || typeof event.content_block.type !== "string")
       return invalidStreamEvent(event)
-    if (event.content_block.type === "compaction") {
-      const decoded = Schema.decodeUnknownOption(AnthropicCompactionBlock)(event.content_block)
-      if (event.index === undefined || Option.isNone(decoded)) return invalidStreamEvent(event)
-      return Effect.succeed<StepResult>([
-        { ...state, compactions: { ...state.compactions, [event.index]: decoded.value.content } },
-        NO_EVENTS,
-      ])
-    }
-    if (!STREAM_BLOCK_TYPES.has(event.content_block.type) && !isServerToolResultType(event.content_block.type))
-      return Effect.succeed<StepResult>([state, NO_EVENTS])
+    if (!isKnownStreamBlockType(event.content_block.type)) return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamBlock(event.content_block)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
     const block = decoded.value
@@ -1591,7 +1470,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
   }
   if (event.type === "content_block_delta") {
     if (!ProviderShared.isRecord(event.delta)) return invalidStreamEvent(event)
-    if (typeof event.delta.type === "string" && !STREAM_DELTA_TYPES.has(event.delta.type))
+    if (typeof event.delta.type === "string" && !isKnownStreamDeltaType(event.delta.type))
       return Effect.succeed<StepResult>([state, NO_EVENTS])
     const decoded = decodeAnthropicStreamDelta(event.delta)
     if (Option.isNone(decoded)) return invalidStreamEvent(event)
@@ -1625,8 +1504,6 @@ export const protocol = Protocol.make({
   stream: {
     event: Protocol.jsonEvent(AnthropicEvent),
     initial: (request) => ({
-      provider: request.model.provider,
-      compactions: {},
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
       reasoningSignatures: {},
@@ -1636,37 +1513,6 @@ export const protocol = Protocol.make({
   },
 })
 
-export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
-  const http = HttpTransport.httpJson<Body, string>({ framing })
-  return {
-    ...http,
-    prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      if (
-        !input.body.context_management?.edits.length &&
-        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        return http.prepare(input)
-      const headers = Headers.fromInput(input.request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      )
-      betas.add("compact-2026-01-12")
-      return http.prepare({
-        ...input,
-        request: LLMRequest.update(input.request, {
-          http: new HttpOptions({
-            ...input.request.http,
-            headers: { ...headers, "anthropic-beta": [...betas].join(",") },
-          }),
-        }),
-      })
-    },
-  }
-}
-
 export const route = Route.make({
   id: ADAPTER,
   provider: "anthropic",
@@ -1676,7 +1522,7 @@ export const route = Route.make({
     baseURL: DEFAULT_BASE_URL,
   }),
   auth: Auth.none,
-  transport: transport<AnthropicMessagesBody>(),
+  framing,
   headers: () => ({ "anthropic-version": "2023-06-01" }),
 })
 

packages/ai/src/protocols/bedrock-converse.ts

@@ -427,22 +427,21 @@ const lowerSystem = (
 
 const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request: LLMRequest) {
   const toolChoice = request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   const generation = request.generation
   // Bedrock-Claude shares Anthropic's 4-breakpoint cap. Spend the budget in
   // tools → system → messages order to favour the highest-impact prefixes.
   const breakpoints = BedrockCache.breakpoints()
   const toolConfig = (() => {
-    if (flattened.tools.length === 0) return undefined
+    if (request.tools.length === 0) return undefined
     return {
-      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, flattened.tools),
+      tools: lowerTools(request.model.compatibility?.toolSchema, breakpoints, request.tools),
       // Converse has no native "none". Keep definitions stable for prompt
       // caching and omit only the unsupported choice.
       toolChoice,
     }
   })()
   const system = lowerSystem(breakpoints, request.system)
-  const messages = yield* lowerMessages(flattened.request, breakpoints)
+  const messages = yield* lowerMessages(request, breakpoints)
   if (breakpoints.dropped > 0) {
     yield* Effect.logWarning(
       `Bedrock Converse: dropped ${breakpoints.dropped} cache breakpoint(s); the API allows at most ${BedrockCache.BEDROCK_BREAKPOINT_CAP} per request.`,
@@ -509,6 +508,7 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
 interface ParserState {
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
+  readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold both in state so `onHalt` can emit exactly
   // one finish after both chunks have had a chance to arrive.
@@ -620,14 +620,16 @@ const step = (state: ParserState, event: BedrockEvent) =>
     }
 
     if (event.contentBlockDelta?.delta?.toolUse) {
-      // A delta for a block that is not open, whether it already stopped or never
-      // started, has nothing to attach to and is dropped.
-      const result = ToolStream.append(
+      const index = event.contentBlockDelta.contentBlockIndex
+      if (state.finishedTools.has(index)) return [state, []] as const
+      const result = ToolStream.appendExisting(
+        ADAPTER,
         state.tools,
-        event.contentBlockDelta.contentBlockIndex,
+        index,
         event.contentBlockDelta.delta.toolUse.input,
+        "Bedrock Converse tool delta is missing its tool call",
       )
-      if (!result) return [state, []] as const
+      if (ToolStream.isError(result)) return yield* result
       const events: LLMEvent[] = []
       const lifecycle = result.events.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
       events.push(...result.events)
@@ -666,6 +668,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
             state.hasToolCalls,
           lifecycle,
           tools: result.tools,
+          finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
           reasoningSignatures: Object.fromEntries(
             Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
           ),
@@ -762,6 +765,7 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
+      finishedTools: new Set<number>(),
       finishReason: undefined,
       usage: undefined,
       hasToolCalls: false,

packages/ai/src/protocols/gemini.ts

@@ -465,8 +465,7 @@ function mapSafetySettings(value: unknown) {
 }
 
 const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMRequest) {
-  const flattened = ProviderShared.flattenToolRequest(request)
-  const hasTools = flattened.tools.length > 0
+  const hasTools = request.tools.length > 0
   const generation = request.generation
   const options = resolveOptions(request)
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
@@ -484,7 +483,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 
   return {
     cachedContent: options.cachedContent,
-    contents: yield* lowerMessages(flattened.request),
+    contents: yield* lowerMessages(request),
     safetySettings: options.safetySettings,
     serviceTier: options.serviceTier,
     systemInstruction:
@@ -492,7 +491,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
     tools: hasTools
       ? [
           {
-            functionDeclarations: flattened.tools.map((tool) =>
+            functionDeclarations: request.tools.map((tool) =>
               lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
             ),
           },

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

@@ -414,11 +414,10 @@ export const fromRequest = Effect.fn("MistralChat.fromRequest")(function* (reque
         tool: (name) => ({ type: "function" as const, function: { name } }),
       })
     : undefined
-  const flattened = ProviderShared.flattenToolRequest(request)
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request),
-    tools: flattened.tools.length > 0 ? flattened.tools.map(lowerTool) : undefined,
+    messages: yield* lowerMessages(request),
+    tools: request.tools.length > 0 ? request.tools.map(lowerTool) : undefined,
     tool_choice: toolChoice,
     stream: true as const,
     max_tokens: request.generation?.maxTokens,

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

@@ -32,19 +32,17 @@ export const PATH = "/responses"
 // =============================================================================
 // Request Body Schema
 // =============================================================================
-export const OpenResponsesInputText = Schema.Struct({
+const OpenResponsesInputText = Schema.Struct({
   type: Schema.tag("input_text"),
   text: Schema.String,
 })
-export const OpenResponsesInputImage = Schema.Struct({
+const OpenResponsesInputImage = Schema.Struct({
   type: Schema.tag("input_image"),
   image_url: Schema.String,
-  detail: Schema.optional(Schema.String),
 })
-export const OpenResponsesInputFile = Schema.Struct({
+const OpenResponsesInputFile = Schema.Struct({
   type: Schema.tag("input_file"),
   filename: Schema.String,
-  detail: Schema.optional(Schema.String),
   file_data: Schema.optional(Schema.String),
   file_url: Schema.optional(Schema.String),
 })
@@ -56,7 +54,7 @@ const MediaInput = Schema.Union([OpenResponsesInputImage, OpenResponsesInputFile
 export type MediaInput = Schema.Schema.Type<typeof MediaInput>
 const OpenResponsesInputContent = Schema.Union([OpenResponsesInputText, MediaInput])
 
-export const OpenResponsesOutputText = Schema.Struct({
+const OpenResponsesOutputText = Schema.Struct({
   type: Schema.tag("output_text"),
   text: Schema.String,
 })
@@ -64,13 +62,6 @@ export const OpenResponsesOutputText = Schema.Struct({
 export const MessagePhase = Schema.NullOr(Schema.Literals(["commentary", "final_answer"]))
 type MessagePhase = Schema.Schema.Type<typeof MessagePhase>
 
-export const MessageMetadata = Schema.Struct({
-  itemId: Schema.optional(Schema.String),
-  type: Schema.optional(Schema.Literal("message")),
-  status: Schema.optional(Schema.String),
-  phase: Schema.optional(MessagePhase),
-})
-
 const messagePhase = (value: unknown): MessagePhase | undefined => {
   if (value === null || value === "commentary" || value === "final_answer") return value
   return undefined
@@ -81,7 +72,7 @@ const OpenResponsesReasoningSummaryText = Schema.Struct({
   text: Schema.String,
 })
 
-export const OpenResponsesReasoningItem = Schema.Struct({
+const OpenResponsesReasoningItem = Schema.Struct({
   type: Schema.tag("reasoning"),
   id: Schema.optionalKey(Schema.String),
   summary: Schema.Array(OpenResponsesReasoningSummaryText),
@@ -158,30 +149,16 @@ const OpenResponsesFunctionCallOutput = Schema.Union([
   Schema.Array(OpenResponsesFunctionCallOutputContent),
 ])
 
-export const CompactionItem = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  id: optionalNull(Schema.String),
-  encrypted_content: Schema.String,
-})
-
 export const InputItem = Schema.Union([
-  CompactionItem,
   Schema.Struct({ role: Schema.tag("system"), content: Schema.String }),
   Schema.Struct({ role: Schema.tag("developer"), content: Schema.String }),
-  Schema.Struct({
-    role: Schema.tag("user"),
-    content: Schema.Array(OpenResponsesInputContent),
-    type: Schema.optional(Schema.Literal("message")),
-    id: Schema.optional(Schema.String),
-    status: Schema.optional(Schema.String),
-  }),
+  Schema.Struct({ role: Schema.tag("user"), content: Schema.Array(OpenResponsesInputContent) }),
   Schema.Struct({
     type: Schema.tag("message"),
     id: Schema.optionalKey(Schema.String),
     role: Schema.tag("assistant"),
     content: Schema.Array(OpenResponsesOutputText),
     phase: Schema.optionalKey(MessagePhase),
-    status: Schema.optional(Schema.String),
   }),
   OpenResponsesReasoningItem,
   Schema.Struct({
@@ -189,7 +166,6 @@ export const InputItem = Schema.Union([
     id: Schema.optionalKey(Schema.String),
     call_id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.String,
   }),
   Schema.Struct({
@@ -291,7 +267,7 @@ const OpenResponsesBody = Schema.Struct({
 })
 export type OpenResponsesBody = Schema.Schema.Type<typeof OpenResponsesBody>
 
-export const OpenResponsesUsage = Schema.Struct({
+const OpenResponsesUsage = Schema.Struct({
   input_tokens: Schema.optional(Schema.Number),
   input_tokens_details: optionalNull(
     Schema.Struct({
@@ -305,25 +281,18 @@ export const OpenResponsesUsage = Schema.Struct({
 })
 type OpenResponsesUsage = Schema.Schema.Type<typeof OpenResponsesUsage>
 
-// The spec requires `id` on every output item, but some gateways drop it from
-// later item events (Bedrock Mantle renames it to `item_id` on
-// `output_item.done` and `response.completed.output`). Decode it as optional
-// and let `normalize` recover or mint it once before the parser runs.
-// https://www.openresponses.org/specification#extending-items
 export const StreamItem = Schema.StructWithRest(
   Schema.Struct({
     type: Schema.String,
     id: Schema.optional(Schema.String),
     call_id: Schema.optional(Schema.String),
     name: Schema.optional(Schema.String),
-    namespace: Schema.optional(Schema.String),
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
   }),
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 export type StreamItem = Schema.Schema.Type<typeof StreamItem>
-export type OutputItem = StreamItem & { readonly id: string }
 
 // The Responses schema puts streaming error details at the top level and
 // response failures under `response.error`. WebSocket failures use an
@@ -403,7 +372,6 @@ export const Event = Schema.StructWithRest(
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 export type Event = Schema.Schema.Type<typeof Event>
-export type NormalizedEvent = Event & { readonly item?: OutputItem | null }
 
 export interface ProviderAdapter {
   readonly id: string
@@ -419,22 +387,26 @@ export interface ProviderAdapter {
 const BASE_ADAPTER: ProviderAdapter = { id: ADAPTER, name: NAME }
 
 export interface ParserState {
-  readonly provider: LLMRequest["model"]["provider"]
-  readonly completedCompactions: ReadonlySet<string>
   readonly id: string
   readonly name: string
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<string>
+  // Call ids stay independent of item ids, which may be omitted or reused.
+  readonly completedTools: ReadonlySet<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly outputItems: Readonly<Record<number, string>>
   readonly message: { readonly id: string; readonly phase: MessagePhase | null | undefined } | undefined
+  // Item ids are response-scoped identities. Keep completed ids tombstoned so
+  // reconnect replay cannot reopen fragments already emitted downstream.
+  readonly completedMessages: ReadonlySet<string>
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
 }
 
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
 
 interface ReasoningStreamItem {
+  readonly open: boolean
   readonly encryptedContent: string | null | undefined
   // Keyed by the wire protocol's numeric `summary_index`. JS object keys coerce to
   // strings, but typing the map as `Record<number, ...>` documents intent
@@ -490,7 +462,6 @@ const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenRes
     ...(id === undefined ? {} : { id }),
     call_id: part.id,
     name: part.name,
-    namespace: part.namespace,
     arguments: ProviderShared.encodeJson(part.input),
   }
 }
@@ -520,9 +491,6 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
   const media = ProviderShared.normalizeMedia(part)
   const providerMedia = adapter.lowerMedia?.({ part, media, request })
   if (providerMedia) return providerMedia
-  const detail = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenResponsesInputImage.fields.detail))(
-    part.providerMetadata?.[metadataKey(request.model)]?.detail,
-  )
   const url =
     typeof part.data === "string" && (part.data.startsWith("https://") || part.data.startsWith("http://"))
       ? part.data
@@ -533,15 +501,10 @@ const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
     return {
       type: "input_file" as const,
       filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
-      detail,
       ...(url ? { file_url: url } : { file_data: media.dataUrl }),
     }
   }
-  return {
-    type: "input_image" as const,
-    image_url: url ?? media.dataUrl,
-    detail,
-  }
+  return { type: "input_image" as const, image_url: url ?? media.dataUrl }
 })
 
 const lowerUserContent = Effect.fnUntraced(function* (
@@ -608,12 +571,9 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
   adapter: ProviderAdapter,
 ) {
   const input: LoweredInputItem[] = []
-  const providerMetadataKey = metadataKey(request.model)
+  const providerMetadataKey = request.model.route.providerMetadataKey ?? "openresponses"
 
   for (const message of request.messages) {
-    const metadata = yield* ProviderShared.validateWith(
-      Schema.decodeUnknownEffect(Schema.UndefinedOr(MessageMetadata)),
-    )(message.providerMetadata?.[providerMetadataKey])
     if (message.role === "system") {
       input.push({
         role: "developer",
@@ -624,8 +584,7 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
 
     if (message.role === "user") {
       const content = yield* Effect.forEach(message.content, (part) => lowerUserContent(part, request, adapter))
-      if (content.length > 0)
-        input.push({ role: "user", content, type: metadata?.type, id: metadata?.itemId, status: metadata?.status })
+      if (content.length > 0) input.push({ role: "user", content })
       continue
     }
 
@@ -638,10 +597,9 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         const groups = content.reduce<
           Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
         >((groups, part) => {
-          const partMetadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey) ?? metadata?.itemId
-          const partPhase = messagePhase(partMetadata?.phase)
-          const phase = partPhase === undefined ? metadata?.phase : partPhase
+          const metadata = part.providerMetadata?.[providerMetadataKey]
+          const id = itemID(part.providerMetadata, providerMetadataKey)
+          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase) : undefined
           const group = groups.at(-1)
           if (group && group.id === id && group.phase === phase) group.parts.push(part)
           else groups.push({ id, phase, parts: [part] })
@@ -652,7 +610,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
             type: "message" as const,
             ...(group.id === undefined ? {} : { id: group.id }),
             role: "assistant" as const,
-            status: metadata?.status,
             content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
             ...(group.phase === undefined ? {} : { phase: group.phase }),
           })),
@@ -660,15 +617,6 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
         content.splice(0, content.length)
       }
       for (const part of message.content) {
-        if (part.type === "compaction") {
-          flushText()
-          if (part.provider !== request.model.provider || part.encrypted === undefined)
-            return yield* ProviderShared.invalidRequest(
-              "Compaction state must be replayed to its originating provider and API",
-            )
-          input.push({ type: "compaction", id: part.id, encrypted_content: part.encrypted })
-          continue
-        }
         if (part.type === "text") {
           content.push(part)
           continue
@@ -745,30 +693,13 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (
   return input
 })
 
-export const lowerConversation = Effect.fn("OpenResponses.lowerConversation")(function* (
-  request: LLMRequest,
-  adapter: ProviderAdapter,
-) {
-  const instructions = ProviderShared.joinText(request.system)
-  return {
-    model: request.model.id,
-    input: yield* lowerMessages(request, adapter),
-    ...(instructions ? { instructions } : {}),
-  }
-})
-
-export const lowerGeneration = (request: LLMRequest) => {
+const lowerOptions = (request: LLMRequest) => {
   const options = OpenResponsesOptions.resolve(request)
-  const generation = request.generation
+  const instructions = ProviderShared.joinText(request.system)
   const cacheKey = ProviderShared.promptCacheKey(request)
   const parallelToolCalls = resolveParallelToolCalls(request)
   return {
-    stream: true as const,
-    max_output_tokens: generation?.maxTokens,
-    temperature: generation?.temperature,
-    top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
+    ...(instructions ? { instructions } : {}),
     ...(options.store !== undefined ? { store: options.store } : {}),
     ...(options.metadata ? { metadata: options.metadata } : {}),
     ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
@@ -796,7 +727,7 @@ export const resolveParallelToolCalls = (request: LLMRequest) => {
   return disabled === undefined ? undefined : !disabled
 }
 
-export const allowedToolChoice = (request: LLMRequest) => {
+const allowedToolChoice = (request: LLMRequest) => {
   const allowed = OpenResponsesOptions.resolve(request).allowedTools
   if (!allowed) return undefined
   return {
@@ -810,15 +741,15 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
   request: LLMRequest,
   adapter: ProviderAdapter,
 ) {
-  const projected = ProviderShared.flattenToolRequest(request)
+  const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
   return {
-    ...(yield* lowerConversation(projected.request, adapter)),
-    ...lowerGeneration(request),
+    model: request.model.id,
+    input: yield* lowerMessages(request, adapter),
     tools:
-      projected.tools.length === 0
+      request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(projected.tools, (tool) =>
+        : yield* Effect.forEach(request.tools, (tool) =>
             lowerTool(
               adapter.name,
               tool,
@@ -828,6 +759,13 @@ export const fromRequestWithAdapter = Effect.fn("OpenResponses.fromRequestWithAd
     tool_choice:
       allowedToolChoice(request) ??
       (request.toolChoice ? yield* lowerToolChoice(adapter.name, request.toolChoice) : undefined),
+    stream: true as const,
+    max_output_tokens: generation?.maxTokens,
+    temperature: generation?.temperature,
+    top_p: generation?.topP,
+    presence_penalty: generation?.presencePenalty,
+    frequency_penalty: generation?.frequencyPenalty,
+    ...lowerOptions(request),
   }
 })
 
@@ -844,7 +782,7 @@ export const fromRequest = Effect.fn("OpenResponses.fromRequest")(function* (req
 // cached-read and cache-write subsets, and `output_tokens` (inclusive total)
 // with a `reasoning_tokens` subset. Pass the totals through and derive the
 // non-cached breakdown.
-export const mapUsage = (usage: OpenResponsesUsage | null | undefined, providerMetadataKey: string) => {
+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
@@ -874,12 +812,13 @@ const mapFinishReason = (event: Event, hasFunctionCall: boolean): FinishReason =
   return hasFunctionCall ? "tool-calls" : "unknown"
 }
 
-export const metadataKey = (model: LLMRequest["model"]) => model.route.providerMetadataKey ?? "openresponses"
-
 export const providerMetadata = (state: ParserState, metadata: Record<string, unknown>): ProviderMetadata => ({
   [state.providerMetadataKey]: metadata,
 })
 
+const isReasoningItem = (item: StreamItem): item is StreamItem & { type: "reasoning"; id: string } =>
+  item.type === "reasoning" && typeof item.id === "string"
+
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 
 const NO_EVENTS: StepResult["1"] = []
@@ -923,37 +862,12 @@ const joinReasoningText = (parts: ReadonlyArray<string | undefined>) => {
   return parts.filter((part) => part !== undefined).join("\n\n")
 }
 
-const outputItemID = (state: ParserState, event: Event) =>
+export const outputItemID = (state: ParserState, event: Event) =>
   event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)
 
-const ITEM_ID_PREFIX: Readonly<Record<string, string>> = {
-  message: "msg",
-  reasoning: "rs",
-  function_call: "fc",
-  compaction: "cmp",
-}
-
-// An item without an id adopts the id already open in its output slot,
-// otherwise it gets a locally minted one.
-const resolveItem = (state: ParserState, item: StreamItem, index: number | undefined): OutputItem => ({
-  ...item,
-  id:
-    item.id ??
-    (index === undefined ? undefined : state.outputItems[index]) ??
-    `${ITEM_ID_PREFIX[item.type] ?? "item"}_${crypto.randomUUID().replaceAll("-", "")}`,
-})
-
-// Registered output slots are authoritative for `item_id` routing, and items
-// are resolved here so everything downstream can rely on `item.id`.
-export const normalize = (state: ParserState, input: Event): NormalizedEvent => ({
-  ...input,
-  item_id: input.item_id === undefined ? undefined : outputItemID(state, input),
-  item: input.item ? resolveItem(state, input.item, input.output_index) : input.item,
-})
-
 const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
+  if (!item?.open || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
 
   const events: LLMEvent[] = []
   const lifecycle = Object.entries(item.summaryParts)
@@ -993,7 +907,7 @@ const startReasoningSummaryPart = (state: ParserState, itemID: string, index: nu
 
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!event.delta || !item) return [state, NO_EVENTS]
+  if (!event.delta || !item?.open) return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
   const [started, emitted] = startReasoningSummaryPart(state, itemID, index)
@@ -1018,13 +932,13 @@ export const onReasoningDelta = (state: ParserState, event: Event, itemID: strin
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
+  if (!item?.open || typeof event.text !== "string") return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
 }
 
-const reasoningMetadata = (state: ParserState, item: OutputItem) =>
+const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
   providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
 
 // Responses APIs normally stream reasoning items in this order:
@@ -1037,16 +951,20 @@ const reasoningMetadata = (state: ParserState, item: OutputItem) =>
 // `onOutputItemAdded` seeds the per-item entry, while each later part start is
 // also an implicit boundary for the previous part. This keeps the common event
 // lifecycle ordered when a compatible provider omits or delays a part-done event.
-const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResult => {
+const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
-  if (!item) return [state, NO_EVENTS]
-  if (item.type === "message") {
+  if (item?.type === "message" && item.id !== undefined) {
+    const itemID = item.id
+    if (state.completedMessages.has(itemID)) return [state, NO_EVENTS]
     const phase = messagePhase(item.phase)
+    const completedMessages = new Set(state.completedMessages)
+    if (state.message !== undefined && state.message.id !== itemID) completedMessages.add(state.message.id)
     // A new message closes earlier messages, including ones that never streamed.
     const events: LLMEvent[] = []
     const lifecycle = [...state.lifecycle.text]
-      .filter((id) => id !== item.id)
+      .filter((id) => id !== itemID)
       .reduce((lifecycle, id) => {
+        completedMessages.add(id)
         const openPhase = state.message?.id === id ? state.message.phase : undefined
         return Lifecycle.textEnd(
           lifecycle,
@@ -1059,15 +977,16 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       {
         ...state,
         lifecycle,
+        completedMessages,
         message: {
-          id: item.id,
-          phase: phase === undefined && state.message?.id === item.id ? state.message.phase : phase,
+          id: itemID,
+          phase: phase === undefined && state.message?.id === itemID ? state.message.phase : phase,
         },
       },
       events,
     ]
   }
-  if (item.type === "reasoning") {
+  if (item && isReasoningItem(item)) {
     if (state.reasoningItems[item.id] !== undefined) return [state, NO_EVENTS]
     const events: LLMEvent[] = []
     return [
@@ -1077,6 +996,7 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
         reasoningItems: {
           ...state.reasoningItems,
           [item.id]: {
+            open: true,
             encryptedContent: item.encrypted_content,
             summaryParts: { 0: "active" },
             deltaIndexes: new Set(),
@@ -1086,32 +1006,25 @@ const onOutputItemAdded = (state: ParserState, event: NormalizedEvent): StepResu
       events,
     ]
   }
-  if (item.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
-  if (state.tools[item.id] !== undefined) return [state, NO_EVENTS]
-  const metadata = providerMetadata(state, { itemId: item.id })
+  if (item?.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
+  const id = item.id ?? item.call_id
+  if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
+    return [state, NO_EVENTS]
+  const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   return [
     {
       ...state,
       lifecycle,
-      tools: ToolStream.start(state.tools, item.id, {
+      tools: ToolStream.start(state.tools, id, {
         id: item.call_id,
         name: item.name ?? "",
-        namespace: item.namespace,
         input: item.arguments ?? "",
         providerMetadata: metadata,
       }),
     },
-    [
-      ...events,
-      LLMEvent.toolInputStart({
-        id: item.call_id,
-        name: item.name ?? "",
-        namespace: item.namespace,
-        providerMetadata: metadata,
-      }),
-    ],
+    [...events, LLMEvent.toolInputStart({ id: item.call_id, name: item.name ?? "", providerMetadata: metadata })],
   ]
 }
 
@@ -1123,7 +1036,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
+  if (!item?.open) return [state, NO_EVENTS]
   if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
   return [
     {
@@ -1176,33 +1089,19 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
 
 const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   state: ParserState,
-  item: NormalizedEvent["item"],
+  item: Event["item"],
 ) {
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
-  if (item.type === "compaction") {
-    if (typeof item.encrypted_content !== "string")
-      return yield* ProviderShared.eventError(state.id, "Compaction output is missing its encrypted content")
-    if (state.completedCompactions.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
-    const events: LLMEvent[] = []
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(
-      LLMEvent.compaction({
-        provider: state.provider,
-        id: item.id,
-        encrypted: item.encrypted_content,
-      }),
-    )
-    return [
-      { ...state, lifecycle, completedCompactions: new Set([...state.completedCompactions, item.id]) },
-      events,
-    ] satisfies StepResult
-  }
-
-  if (item.type === "message") {
-    const active = state.message?.id === item.id
+  if (item.type === "message" && item.id !== undefined) {
+    if (state.completedMessages.has(item.id)) return [state, NO_EVENTS] satisfies StepResult
+    const completedMessages = new Set(state.completedMessages)
+    completedMessages.add(item.id)
+    if (state.message !== undefined && state.message.id !== item.id)
+      return [{ ...state, completedMessages }, NO_EVENTS] satisfies StepResult
+    const message = state.message
     const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined && active ? state.message?.phase : itemPhase
+    const phase = itemPhase === undefined ? message?.phase : itemPhase
     const parts: ReadonlyArray<unknown> = Array.isArray(item.content) ? item.content : []
     const content: string[] = []
     for (const part of parts) {
@@ -1218,7 +1117,8 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
       {
         ...state,
         lifecycle: Lifecycle.textEnd(lifecycle, events, item.id, metadata, text),
-        message: active ? undefined : state.message,
+        completedMessages,
+        message: undefined,
       },
       events,
     ] satisfies StepResult
@@ -1226,35 +1126,36 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const metadata = providerMetadata(state, { itemId: item.id })
-    const registered = state.tools[item.id] !== undefined
-    const tools = registered
-      ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          namespace: item.namespace,
-          providerMetadata: metadata,
-        })
+    const callID = item.call_id
+    if (state.completedTools.has(callID)) return [state, NO_EVENTS] satisfies StepResult
+    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
+    const fallback = item.id ?? callID
+    // Match the pending tool by call id so item events that disagree on
+    // whether `item.id` is present still resolve the same call.
+    const registered =
+      state.tools[fallback] !== undefined
+        ? fallback
+        : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID)
+    const id = registered ?? fallback
+    const tools =
+      registered !== undefined
+        ? state.tools
+        : ToolStream.start(state.tools, id, {
+            id: callID,
+            name: item.name,
+            providerMetadata: metadata,
+          })
     const result =
       item.arguments === undefined
-        ? yield* ToolStream.finish(state.id, tools, item.id)
-        : yield* ToolStream.finishWithInput(state.id, tools, item.id, item.arguments)
+        ? yield* ToolStream.finish(state.id, tools, id)
+        : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments)
     const events: LLMEvent[] = []
     const finished = result.events ?? []
     // A done-only call never streamed a start event, so open its lifecycle here.
     const resultEvents =
-      registered || finished.length === 0
+      registered !== undefined || finished.length === 0
         ? finished
-        : [
-            LLMEvent.toolInputStart({
-              id: item.call_id,
-              name: item.name,
-              namespace: item.namespace,
-              providerMetadata: metadata,
-            }),
-            ...finished,
-          ]
+        : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished]
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [
@@ -1265,12 +1166,14 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
           state.hasFunctionCall,
         tools: result.tools,
+        completedTools: new Set([...state.completedTools, callID]),
       },
       events,
     ] satisfies StepResult
   }
 
-  if (item.type === "reasoning") {
+  if (isReasoningItem(item)) {
+    if (state.reasoningItems[item.id]?.open === false) return [state, NO_EVENTS] satisfies StepResult
     const metadata = reasoningMetadata(state, item)
     const summaryParts: ReadonlyArray<unknown> = Array.isArray(item.summary) ? item.summary : []
     const summary: Array<string | undefined> = []
@@ -1297,14 +1200,53 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
         const finalText = fragments.length === 1 ? itemText : summary[Number(index)]
         lifecycle = Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${index}`, metadata, finalText || undefined)
       }
-      const reasoningItems = { ...state.reasoningItems }
-      delete reasoningItems[item.id]
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              ...reasoningItem,
+              open: false,
+              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
     }
-    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-    events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
-    events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata, text: itemText }))
-    return [{ ...state, lifecycle }, events] satisfies StepResult
+    if (!state.lifecycle.reasoning.has(item.id)) {
+      const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+      events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
+      events.push(
+        LLMEvent.reasoningEnd({
+          id: item.id,
+          providerMetadata: metadata,
+          text: itemText,
+        }),
+      )
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              open: false,
+              encryptedContent: item.encrypted_content,
+              summaryParts: { 0: "concluded" },
+              deltaIndexes: new Set(),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
+    }
+    return [
+      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
+      events,
+    ] satisfies StepResult
   }
 
   return [state, NO_EVENTS] satisfies StepResult
@@ -1314,35 +1256,30 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
   let current = state
   const events: LLMEvent[] = []
   if (event.type === "response.completed") {
-    // An output item's array position is its output index.
-    for (const item of (event.response?.output ?? []).map((item, index) => resolveItem(state, item, index))) {
-      // Terminal recovery cannot insert a checkpoint before already-emitted content.
-      if (item.type === "compaction" && state.lifecycle.stepStarted && !state.completedCompactions.has(item.id))
-        return yield* ProviderShared.eventError(
-          state.id,
-          "Cannot recover a compaction checkpoint after output has been emitted",
-        )
-      const recoverable =
-        item.type === "compaction" || (item.type === "function_call" && current.tools[item.id] !== undefined)
-      if (!recoverable) continue
+    for (const item of event.response?.output ?? []) {
+      if (
+        item.type !== "function_call" ||
+        !item.call_id ||
+        !Object.values(current.tools).some((tool) => tool?.id === item.call_id)
+      )
+        continue
       const [next, emitted] = yield* onOutputItemDone(current, item)
       current = next
       events.push(...emitted)
     }
-    // Some compatible providers omit output_item.done even after completing the response.
-    const pending = yield* ToolStream.finishAll(current.id, current.tools)
-    current = {
-      ...current,
-      tools: pending.tools,
-      hasFunctionCall:
-        current.hasFunctionCall ||
-        pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)),
-    }
-    events.push(...pending.events)
   }
+  // Some compatible providers omit output_item.done even after completing the response.
+  const pending =
+    event.type === "response.completed"
+      ? yield* ToolStream.finishAll(current.id, current.tools)
+      : { tools: current.tools, events: NO_EVENTS }
+  events.push(...pending.events)
+  const hasFunctionCall =
+    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
+    current.hasFunctionCall
   const lifecycle = Lifecycle.finish(current.lifecycle, events, {
     reason: {
-      normalized: mapFinishReason(event, current.hasFunctionCall),
+      normalized: mapFinishReason(event, hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
     usage: mapUsage(event.response?.usage, current.providerMetadataKey),
@@ -1354,7 +1291,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
           })
         : undefined,
   })
-  return [{ ...current, lifecycle }, events] satisfies StepResult
+  return [{ ...current, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
 })
 
 // Build the prettiest summary available from whatever the provider supplied.
@@ -1391,9 +1328,12 @@ export const providerFailure = (event: Event, fallback: string, body = ProviderS
   return new AIError({ reason })
 }
 
-// Callers must pass events through `normalize` first. The OpenAPI requires
-// string IDs but imposes no minLength; empty is not missing.
-export const step = (state: ParserState, event: NormalizedEvent) => {
+export const step = (state: ParserState, input: Event) => {
+  // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
+  const event =
+    input.item_id !== undefined && outputItemID(state, input) !== input.item_id
+      ? { ...input, item_id: outputItemID(state, input) }
+      : input
   if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
     if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(
@@ -1433,16 +1373,20 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
       ? 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 === undefined)
+      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     if (
-      event.item?.type === "reasoning" &&
+      event.item &&
+      isReasoningItem(event.item) &&
       state.reasoningItems[event.item.id] === undefined &&
       state.lifecycle.reasoning.size > 0
     )
       return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`)
+    const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
     return Effect.succeed(
       onOutputItemAdded(
-        event.output_index !== undefined && event.item
-          ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: event.item.id } }
+        event.output_index !== undefined && id !== undefined
+          ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
           : state,
         event,
       ),
@@ -1452,7 +1396,11 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
     return event.item_id !== undefined
       ? onFunctionCallArgumentsDelta(state, event)
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
-  if (event.type === "response.output_item.done") return onOutputItemDone(state, event.item)
+  if (event.type === "response.output_item.done") {
+    if (event.item?.type === "message" && event.item.id === undefined)
+      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
+    return onOutputItemDone(state, event.item)
+  }
   if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
   if (event.type === "response.failed") return providerFailure(event, `${state.name} response failed`)
   if (event.type === "error")
@@ -1478,16 +1426,16 @@ export const step = (state: ParserState, event: NormalizedEvent) => {
  * implementations compose this baseline with their own tools and event variants.
  */
 export const initial = (request: LLMRequest, adapter: ProviderAdapter = BASE_ADAPTER): ParserState => ({
-  provider: request.model.provider,
-  completedCompactions: new Set<string>(),
   id: adapter.id,
   name: adapter.name,
-  providerMetadataKey: metadataKey(request.model),
+  providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
+  completedTools: new Set<string>(),
   lifecycle: Lifecycle.initial(),
   outputItems: {},
   message: undefined,
+  completedMessages: new Set<string>(),
   reasoningItems: {},
 })
 
@@ -1500,7 +1448,7 @@ export const protocol = Protocol.make({
   stream: {
     event: Protocol.jsonEvent(Event),
     initial,
-    step: (state: ParserState, event: Event) => step(state, normalize(state, event)),
+    step,
     terminal,
   },
 })

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

@@ -736,7 +736,6 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
     )
   const generation = request.generation
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
-  const flattened = ProviderShared.flattenToolRequest(request)
   const provider = String(request.model.provider)
   const baseURL = request.model.route.endpoint.baseURL
   const detectedMaxTokensField = detectMaxTokensField(provider, baseURL)
@@ -749,16 +748,16 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const zaiToolStream =
     request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
   const hasHistory = hasToolHistory(request.messages)
-  const hasActiveTools = flattened.tools.length > 0
+  const hasActiveTools = request.tools.length > 0
   return {
     model: request.model.id,
-    messages: yield* lowerMessages(flattened.request, options),
+    messages: yield* lowerMessages(request, options),
     tools:
-      flattened.tools.length === 0
+      request.tools.length === 0
         ? hasHistory
           ? []
           : undefined
-        : flattened.tools.map((tool) =>
+        : request.tools.map((tool) =>
             lowerTool(
               tool,
               ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility),

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

@@ -5,14 +5,13 @@ import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
 import { Protocol } from "../route/protocol.js"
 import { HttpTransport } from "../route/transport/index.js"
-import type { LLMRequest, JsonSchema, ToolDefinition, ToolEntry } from "../schema/index.js"
+import { LLMRequest, type JsonSchema, type ToolDefinition } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { OpenResponsesChannel } from "./open-responses-channel.js"
-import { ResponsesCompaction } from "./utils/responses-compaction.js"
 
 const ADAPTER = "openai-responses"
 const NAME = "OpenAI Responses"
@@ -21,14 +20,6 @@ const WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = OpenResponses.PATH
 
-export const ContextManagement = Schema.Array(
-  Schema.Struct({
-    type: Schema.Literal("compaction"),
-    compactThreshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
-  }),
-)
-export type ContextManagement = typeof ContextManagement.Type
-
 const OpenAIResponsesImageGenerationTool = Schema.Struct({
   type: Schema.tag("image_generation"),
   action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
@@ -75,18 +66,7 @@ const OpenAIResponsesHostedToolItem = Schema.Union([
   ),
 ])
 
-const OpenAIResponsesNamespace = Schema.Struct({
-  type: Schema.tag("namespace"),
-  name: Schema.String,
-  description: Schema.String,
-  tools: Schema.Array(OpenResponses.Tool),
-})
-
-const OpenAIResponsesTools = Schema.Union([
-  OpenResponses.Tool,
-  OpenAIResponsesNamespace,
-  OpenAIResponsesImageGenerationTool,
-])
+const OpenAIResponsesTools = Schema.Union([OpenResponses.Tool, OpenAIResponsesImageGenerationTool])
 
 const OpenAIResponsesToolChoice = Schema.Union([
   OpenResponses.ToolChoice,
@@ -98,14 +78,6 @@ const OpenAIResponsesCoreFields = {
   input: Schema.Array(Schema.Union([OpenResponses.InputItem, OpenAIResponsesHostedToolItem])),
   tools: optionalArray(OpenAIResponsesTools),
   tool_choice: Schema.optional(OpenAIResponsesToolChoice),
-  context_management: Schema.optional(
-    Schema.Array(
-      Schema.Struct({
-        type: Schema.Literal("compaction"),
-        compact_threshold: Schema.optional(Schema.Int.check(Schema.isGreaterThan(0))),
-      }),
-    ),
-  ),
 }
 
 const OpenAIResponsesBody = Schema.Struct({
@@ -139,33 +111,13 @@ const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool: ToolDe
   return yield* OpenResponses.lowerTool(NAME, tool, inputSchema)
 })
 
-// Native namespaces hold only function tools, so deeper levels flatten into
-// the leaf names the same way non-native protocols flatten the whole tree.
-const lowerToolEntry = Effect.fn("OpenAIResponses.lowerToolEntry")(function* (
-  tool: ToolEntry,
-  compatibility: Parameters<typeof ToolSchemaProjection.modelCompatibility>[1],
-) {
-  if (tool.type === "tool")
-    return yield* lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, compatibility))
-  // OpenAI requires a namespace description; fall back to a generic one so a
-  // missing description never blocks the request.
-  return {
-    type: "namespace" as const,
-    name: tool.name,
-    description: tool.description ?? `Tools in the ${tool.name} namespace.`,
-    tools: yield* Effect.forEach(ProviderShared.flattenTools(tool.tools), (leaf) =>
-      OpenResponses.lowerTool(NAME, leaf, ToolSchemaProjection.modelCompatibility(leaf.inputSchema, compatibility)),
-    ),
-  }
-})
-
-const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolEntry>) =>
+const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tools: ReadonlyArray<ToolDefinition>) =>
   ProviderShared.matchToolChoice(NAME, toolChoice, {
     auto: () => "auto" as const,
     none: () => "none" as const,
     required: () => "required" as const,
     tool: (name) =>
-      tools.some((tool) => tool.type === "tool" && tool.name === name && nativeImageTool(tool) !== undefined)
+      tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
         ? ({ type: "image_generation" } as const)
         : { type: "function" as const, name },
   })
@@ -173,21 +125,23 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>, tool
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIResponsesBody))
 
 const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request: LLMRequest) {
-  const management = yield* ProviderShared.validateWith(
-    Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)),
-  )(request.providerOptions?.contextManagement)
+  const body = yield* OpenResponses.fromRequestWithAdapter(
+    LLMRequest.update(request, { tools: [], toolChoice: undefined }),
+    adapter,
+  )
   const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const parallelToolCalls = OpenResponses.resolveParallelToolCalls(request)
   return yield* decodeBody({
-    ...(yield* OpenResponses.lowerConversation(request, adapter)),
-    ...OpenResponses.lowerGeneration(request),
-    context_management: management?.map((edit) => ({ type: edit.type, compact_threshold: edit.compactThreshold })),
+    ...body,
+    ...(parallelToolCalls === undefined ? {} : { parallel_tool_calls: parallelToolCalls }),
     tools:
       request.tools.length === 0
         ? undefined
-        : yield* Effect.forEach(request.tools, (tool) => lowerToolEntry(tool, toolSchemaCompatibility)),
+        : yield* Effect.forEach(request.tools, (tool) =>
+            lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility)),
+          ),
     tool_choice:
-      OpenResponses.allowedToolChoice(request) ??
-      (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
+      body.tool_choice ?? (request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined),
   })
 })
 
@@ -230,11 +184,12 @@ const HOSTED_TOOLS = {
   },
 } as const satisfies ResponsesHostedTools.Definitions
 
-const step = (state: OpenResponses.ParserState, input: OpenResponses.Event) => {
-  const event = OpenResponses.normalize(state, input)
+const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.reasoning_text.delta")
     return event.item_id !== undefined
-      ? Effect.succeed(OpenResponses.onReasoningDelta(state, event, event.item_id))
+      ? Effect.succeed(
+          OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id),
+        )
       : ProviderShared.eventError(ADAPTER, `${event.type} is missing item_id`)
   if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
     return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
@@ -268,7 +223,6 @@ export const transport = channelTransport({
 })
 
 export const route = Route.make({
-  compact: ResponsesCompaction.make(adapter),
   id: ADAPTER,
   provider: "openai",
   providerMetadataKey: "openai",

packages/ai/src/protocols/shared.ts

@@ -6,17 +6,12 @@ import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/
 import {
   InvalidProviderOutputError,
   InvalidRequestError,
-  UnsupportedOperationError,
   AIError,
   HttpContext,
-  LLMRequest,
-  Message,
-  ToolDefinition,
   type ContentPart,
+  type LLMRequest,
   type MediaPart,
-  type ProviderID,
   type TextPart,
-  type ToolEntry,
   type ToolResultPart,
 } from "../schema/index.js"
 import { isRecord } from "../utils/record.js"
@@ -49,7 +44,6 @@ export const promptCacheKey = (request: LLMRequest): string | undefined => {
 export interface ToolAccumulator {
   readonly id: string
   readonly name: string
-  readonly namespace?: string
   readonly input: string
 }
 
@@ -260,61 +254,6 @@ export const invalidRequest = (message: string, cause?: unknown) =>
     reason: new InvalidRequestError({ message, cause }),
   })
 
-/**
- * Canonical constructor for operations the selected route does not implement.
- * Prefer this over `invalidRequest` when the failure is a missing route
- * capability rather than a malformed caller input, so consumers can branch on
- * `reason._tag` plus `reason.operation` instead of matching message text.
- */
-export const unsupportedOperation = (input: {
-  readonly operation: string
-  readonly message: string
-  readonly provider?: ProviderID
-  readonly route?: string
-  readonly cause?: unknown
-}) =>
-  new AIError({
-    reason: new UnsupportedOperationError({
-      operation: input.operation,
-      message: input.message,
-      provider: input.provider,
-      route: input.route,
-      cause: input.cause,
-    }),
-  })
-
-/**
- * Lower namespaces to flat definitions for protocols without a native
- * namespace construct. Leaf names join their namespace path with `_` because
- * `.` is not broadly accepted in provider tool names.
- */
-export const flattenTools = (tools: ReadonlyArray<ToolEntry>, path: ReadonlyArray<string> = []) => {
-  const flat = tools.flatMap((tool): ReadonlyArray<ToolDefinition> => {
-    if (tool.type === "namespace") return flattenTools(tool.tools, [...path, tool.name])
-    if (path.length === 0) return [tool]
-    return [new ToolDefinition({ ...tool, name: [...path, tool.name].join("_") })]
-  })
-  return [...new Map(flat.map((tool) => [tool.name, tool])).values()]
-}
-
-export const flattenToolRequest = (request: LLMRequest) => {
-  const messages = request.messages.map((message) => {
-    const content = message.content.map((part) => {
-      if ((part.type !== "tool-call" && part.type !== "tool-result") || part.namespace === undefined) return part
-      return { ...part, name: `${part.namespace}_${part.name}`, namespace: undefined }
-    })
-    return content.every((part, index) => part === message.content[index])
-      ? message
-      : new Message({ ...message, content })
-  })
-  return {
-    tools: flattenTools(request.tools),
-    request: messages.every((message, index) => message === request.messages[index])
-      ? request
-      : LLMRequest.update(request, { messages }),
-  }
-}
-
 export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
   route: string,
   name: string,

packages/ai/src/protocols/utils/responses-compaction.ts

@@ -1,174 +0,0 @@
-import { Effect, Schema, Stream } from "effect"
-import {
-  AIError,
-  InvalidProviderOutputError,
-  CompactionPart,
-  CompactionResponse,
-  HttpOptions,
-  LLMRequest,
-  Message,
-  type ContentPart,
-  mergeJsonRecords,
-} from "../../schema/index.js"
-import type { CompactOperation } from "../../route/client.js"
-import { Endpoint } from "../../route/endpoint.js"
-import { RequestExecutor } from "../../route/executor.js"
-import { HttpTransport } from "../../route/transport/index.js"
-import { OpenResponses } from "../open-responses.js"
-import { JsonObject, optionalNull, ProviderShared } from "../shared.js"
-
-const Body = Schema.Struct({
-  model: Schema.String,
-  input: Schema.Array(Schema.Unknown),
-  instructions: optionalNull(Schema.String),
-  previous_response_id: optionalNull(Schema.String),
-  service_tier: optionalNull(Schema.String),
-  prompt_cache_key: optionalNull(Schema.String),
-  prompt_cache_retention: optionalNull(Schema.String),
-  prompt_cache_options: optionalNull(
-    Schema.Struct({ mode: Schema.optional(Schema.String), ttl: Schema.optional(Schema.String) }),
-  ),
-})
-
-const Text = Schema.Union([OpenResponses.OpenResponsesInputText, OpenResponses.OpenResponsesOutputText])
-const File = Schema.Union([
-  Schema.Struct({
-    ...OpenResponses.OpenResponsesInputFile.fields,
-    file_url: Schema.String,
-    file_data: Schema.optional(Schema.Never),
-  }),
-  Schema.Struct({
-    ...OpenResponses.OpenResponsesInputFile.fields,
-    file_data: Schema.String,
-    file_url: Schema.optional(Schema.Never),
-  }),
-])
-const MessageFields = {
-  type: Schema.Literal("message"),
-  id: Schema.optional(Schema.String),
-  status: Schema.optional(Schema.String),
-  phase: Schema.optional(OpenResponses.MessagePhase),
-}
-const Response = Schema.Struct({
-  object: Schema.Literal("response.compaction"),
-  output: Schema.Array(
-    Schema.Union([
-      OpenResponses.CompactionItem,
-      OpenResponses.OpenResponsesReasoningItem,
-      Schema.Struct({
-        ...MessageFields,
-        role: Schema.Literal("user"),
-        content: Schema.Array(Schema.Union([Text, OpenResponses.OpenResponsesInputImage, File])).check(
-          Schema.isMinLength(1),
-        ),
-      }),
-      Schema.Struct({
-        ...MessageFields,
-        role: Schema.Literal("assistant"),
-        content: Schema.Array(Text).check(Schema.isMinLength(1)),
-      }),
-    ]),
-  ),
-  usage: Schema.optional(Schema.StructWithRest(OpenResponses.OpenResponsesUsage, [JsonObject])),
-})
-
-export const make = (adapter: OpenResponses.ProviderAdapter): CompactOperation =>
-  Effect.fn("ResponsesCompaction.execute")(function* (request, executor, options) {
-    const route = request.model.route
-    const native = yield* OpenResponses.lowerConversation(request, adapter)
-    const body = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Body))(
-      mergeJsonRecords(
-        {
-          ...native,
-          service_tier: request.providerOptions?.serviceTier,
-          prompt_cache_key: ProviderShared.promptCacheKey(request),
-        },
-        request.http?.body,
-      ),
-    )
-    const url = Endpoint.render(route.endpoint, { request, body: native })
-    url.pathname = `${url.pathname.replace(/\/$/, "")}/compact`
-    const parts = yield* HttpTransport.jsonRequestParts({
-      request: LLMRequest.update(request, {
-        http: request.http === undefined ? undefined : new HttpOptions({ ...request.http, body: undefined }),
-      }),
-      body,
-      endpoint: Endpoint.path(url.toString()),
-      auth: route.auth,
-      encodeBody: Schema.encodeSync(Schema.fromJsonString(Body)),
-    })
-    const response = yield* executor.execute(
-      ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
-      options?.http,
-    )
-    const text = yield* RequestExecutor.responseStream(response).pipe(
-      Stream.decodeText(),
-      Stream.runFold(
-        () => "",
-        (text, chunk) => text + chunk,
-      ),
-    )
-    const invalid = (message: string, cause?: unknown) =>
-      new AIError({
-        reason: new InvalidProviderOutputError({
-          route: route.id,
-          message,
-          body: text,
-          cause,
-          http: RequestExecutor.responseHttp(response),
-        }),
-      })
-    const result = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(
-      Effect.mapError((cause) => invalid("Invalid compaction response", cause)),
-    )
-    if (!result.output.some((item) => item.type === "compaction"))
-      return yield* invalid("Compaction response did not contain a checkpoint")
-    return new CompactionResponse({
-      replacement: result.output.map((item) => toMessage(item, request.model)),
-      usage: OpenResponses.mapUsage(result.usage, OpenResponses.metadataKey(request.model)),
-    })
-  })
-
-function toMessage(item: (typeof Response.Type.output)[number], model: LLMRequest["model"]): Message {
-  if (item.type === "compaction")
-    return Message.assistant(
-      CompactionPart.make({ provider: model.provider, id: item.id ?? undefined, encrypted: item.encrypted_content }),
-    )
-
-  const key = OpenResponses.metadataKey(model)
-  if (item.type === "reasoning") {
-    const summary = item.summary.length ? item.summary : [{ text: "" }]
-    return Message.assistant(
-      summary.map((part) => ({
-        type: "reasoning" as const,
-        text: part.text,
-        providerMetadata: { [key]: { itemId: item.id, reasoningEncryptedContent: item.encrypted_content } },
-      })),
-    )
-  }
-
-  return Message.make({
-    role: item.role,
-    providerMetadata: { [key]: { itemId: item.id, type: item.type, status: item.status, phase: item.phase } },
-    content: item.content.map((part): ContentPart => {
-      if (part.type === "input_text" || part.type === "output_text") return { type: "text", text: part.text }
-      if (part.type === "input_image")
-        return {
-          type: "media",
-          data: part.image_url,
-          mediaType: /^data:([^;,]+)/.exec(part.image_url)?.[1] ?? "image/*",
-          providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
-        }
-      const data = part.file_url === undefined ? part.file_data : part.file_url
-      return {
-        type: "media",
-        data,
-        filename: part.filename,
-        mediaType: /^data:([^;,]+)/.exec(data)?.[1] ?? "application/octet-stream",
-        providerMetadata: part.detail === undefined ? undefined : { [key]: { detail: part.detail } },
-      }
-    }),
-  })
-}
-
-export * as ResponsesCompaction from "./responses-compaction.js"

packages/ai/src/protocols/utils/responses-hosted-tools.ts

@@ -3,7 +3,8 @@ import { LLMEvent, type AIError, type ToolResultPart } from "../../schema/index.
 import { OpenResponses } from "../open-responses.js"
 import { Lifecycle } from "./lifecycle.js"
 
-export type Item = OpenResponses.OutputItem & {
+export type Item = OpenResponses.StreamItem & {
+  readonly id: string
   readonly status?: string
   readonly action?: unknown
   readonly queries?: unknown
@@ -26,8 +27,8 @@ export interface Definition {
 
 export type Definitions = Readonly<Record<string, Definition>>
 
-export const isItem = <Tools extends Definitions>(item: OpenResponses.OutputItem, tools: Tools): item is Item =>
-  item.type in tools
+export const isItem = <Tools extends Definitions>(item: OpenResponses.StreamItem, tools: Tools): item is Item =>
+  item.type in tools && typeof item.id === "string" && item.id.length > 0
 
 export const onDone: (
   state: OpenResponses.ParserState,

packages/ai/src/protocols/utils/tool-stream.ts

@@ -55,7 +55,6 @@ const inputStart = (tool: PendingTool) =>
   LLMEvent.toolInputStart({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     providerExecuted: tool.providerExecuted ? true : undefined,
     providerMetadata: tool.providerMetadata,
   })
@@ -64,7 +63,6 @@ const inputDelta = (tool: PendingTool, text: string) =>
   LLMEvent.toolInputDelta({
     id: tool.id,
     name: tool.name,
-    namespace: tool.namespace,
     text,
     input: Option.getOrElse(parsePartialInput(tool.input), () => ({})),
   })
@@ -87,7 +85,6 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
         LLMEvent.toolCall({
           id: tool.id,
           name: tool.name,
-          namespace: tool.namespace,
           input,
           providerExecuted: tool.providerExecuted ? true : undefined,
           providerMetadata: tool.providerMetadata,
@@ -97,12 +94,7 @@ const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
 }
 
 const finishEvents = (tool: PendingTool, event: ToolCall): ReadonlyArray<LLMEvent> => [
-  LLMEvent.toolInputEnd({
-    id: tool.id,
-    name: tool.name,
-    namespace: tool.namespace,
-    providerMetadata: tool.providerMetadata,
-  }),
+  LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
   event,
 ]
 
@@ -158,7 +150,6 @@ export const appendOrStart = <K extends StreamKey>(
   const tool = {
     id,
     name,
-    namespace: current?.namespace,
     input: `${current?.input ?? ""}${delta.text}`,
     providerExecuted: current?.providerExecuted,
     providerMetadata: current?.providerMetadata,
@@ -168,17 +159,6 @@ export const appendOrStart = <K extends StreamKey>(
   return appendTool(tools, key, tool, delta.text)
 }
 
-/**
- * Append argument text to a started tool. Returns `undefined` when no tool is
- * open under `key`, for protocols that ignore deltas without a matching block.
- */
-export const append = <K extends StreamKey>(tools: State<K>, key: K, text: string): AppendOutcome<K> | undefined => {
-  const current = tools[key]
-  if (!current) return undefined
-  if (text.length === 0) return { tools, tool: current, events: [] }
-  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
-}
-
 /**
  * Append argument text to a tool that must already have been started. This keeps
  * protocols honest when their stream grammar promises a start event before any
@@ -190,7 +170,12 @@ export const appendExisting = <K extends StreamKey>(
   key: K,
   text: string,
   missingToolMessage: string,
-): AppendOutcome<K> | AIError => append(tools, key, text) ?? eventError(route, missingToolMessage)
+): AppendOutcome<K> | AIError => {
+  const current = tools[key]
+  if (!current) return eventError(route, missingToolMessage)
+  if (text.length === 0) return { tools, tool: current, events: [] }
+  return appendTool(tools, key, { ...current, input: `${current.input}${text}` }, text)
+}
 
 /**
  * Finalize one pending tool call: parse the accumulated raw JSON, remove it

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

@@ -4,7 +4,6 @@ import type { LLMRequest } from "../schema/index.js"
 import { OpenResponses } from "./open-responses.js"
 import { JsonObject, optionalNull, ProviderShared } from "./shared.js"
 import { ResponsesHostedTools } from "./utils/responses-hosted-tools.js"
-import { ResponsesCompaction } from "./utils/responses-compaction.js"
 
 const ADAPTER = "xai-responses"
 const NAME = "xAI Responses"
@@ -45,13 +44,6 @@ const adapter = {
 
 const decodeBody = ProviderShared.validateWith(Schema.decodeUnknownEffect(XAIResponsesBody))
 const fromRequest = Effect.fn("XAIResponses.fromRequest")(function* (request: LLMRequest) {
-  if (request.providerOptions?.contextManagement !== undefined)
-    return yield* ProviderShared.unsupportedOperation({
-      operation: "in-band-compaction",
-      provider: request.model.provider,
-      route: request.model.route.id,
-      message: "xAI requires explicit compaction through LLMClient.compact; automatic context management is not supported",
-    })
   return yield* decodeBody(yield* OpenResponses.fromRequestWithAdapter(request, adapter))
 })
 
@@ -72,8 +64,7 @@ const HOSTED_TOOLS = {
 
 // Grok speaks the standard Responses reasoning dialect (`reasoning_summary_text.*`,
 // handled by the baseline); only its hosted tool vocabulary differs.
-const step = (state: OpenResponses.ParserState, input: OpenResponses.Event) => {
-  const event = OpenResponses.normalize(state, input)
+const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.output_item.done" && event.item && ResponsesHostedTools.isItem(event.item, HOSTED_TOOLS))
     return ResponsesHostedTools.onDone(state, event.item, HOSTED_TOOLS)
   return OpenResponses.step(state, event)
@@ -93,6 +84,4 @@ export const protocol = Protocol.make({
   },
 })
 
-export const compact = ResponsesCompaction.make(adapter)
-
 export * as XAIResponses from "./xai-responses.js"

packages/ai/src/provider-package.ts

@@ -1,5 +1,4 @@
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
-import type { CompactOperation } from "./route/client.js"
 
 export interface Settings extends Readonly<Record<string, unknown>> {
   readonly baseURL?: string
@@ -10,9 +9,8 @@ export interface Settings extends Readonly<Record<string, unknown>> {
 export interface Definition<
   ProviderSettings extends Settings = Settings,
   Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactOperation | undefined = CompactOperation | undefined,
 > {
-  readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options, Compact>
+  readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>
 }
 
 export * as ProviderPackage from "./provider-package.js"

packages/ai/src/providers/azure.ts

@@ -1,7 +1,7 @@
 import { Headers } from "effect/unstable/http"
 import { Auth } from "../route/auth.js"
 import { type AtLeastOne, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactOperation } from "../route/client.js"
+import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -102,11 +102,7 @@ const auth = (input: Config) => {
   )
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactOperation | undefined>(
-  route: Route<Body, Prepared, Compact>,
-  input: Config,
-  modelID: string | ModelID,
-) =>
+const configuredRoute = <Body, Prepared>(route: RouteDef<Body, Prepared>, input: Config, modelID: string | ModelID) =>
   route.with({
     auth: auth(input),
     endpoint: endpoint(input, modelID),
@@ -165,11 +161,10 @@ const config = (settings: Settings): Config => {
   throw new Error("Azure requires resourceName or baseURL")
 }
 
-export const responsesModel: ProviderPackage.Definition<
-  Settings,
-  OpenAIProviderOptionsInput,
-  CompactOperation
->["model"] = (modelID, settings) => configure(config(settings)).responses(modelID)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).responses(modelID)
 export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
   modelID,
   settings,

packages/ai/src/providers/google-vertex-messages.ts

@@ -57,9 +57,7 @@ const route = Route.make({
   }),
   endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
   auth: Auth.none,
-  transport: AnthropicMessages.transport<
-    Omit<AnthropicMessages.AnthropicMessagesBody, "model"> & { readonly anthropic_version: typeof VERSION }
-  >(),
+  framing: AnthropicMessages.framing,
   headers: () => ({ "anthropic-version": HEADER_VERSION }),
 })
 

packages/ai/src/providers/openai-options.ts

@@ -1,13 +1,10 @@
 import { mergeProviderOptions, type ProviderOptions } from "../schema/index.js"
 import type { OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 import type { Options } from "../protocols/utils/open-responses-options.js"
-import type { ContextManagement } from "../protocols/openai-responses.js"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = Omit<Options, "serviceTier"> & {
-  /** Advanced in-band compaction. The caller owns checkpoint persistence and recovery. */
-  readonly contextManagement?: ContextManagement
   readonly serviceTier?: OpenAIServiceTier
   readonly [key: string]: unknown
 }

packages/ai/src/providers/openai.ts

@@ -1,5 +1,5 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import type { Route, RouteDefaultsInput, CompactOperation } from "../route/client.js"
+import type { Route, RouteDefaultsInput } from "../route/client.js"
 import type { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
@@ -73,10 +73,7 @@ const defaults = (input: Config) => {
   return rest
 }
 
-const configuredRoute = <Body, Prepared, Compact extends CompactOperation | undefined>(
-  route: Route<Body, Prepared, Compact>,
-  input: Config,
-) =>
+const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
   route.with({
     auth: auth(input),
     endpoint: { baseURL: input.baseURL, query: input.queryParams },
@@ -132,10 +129,7 @@ const config = (settings: Settings): Config => {
   }
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput, CompactOperation>["model"] = (
-  modelID,
-  settings,
-) => {
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
   return configure(config(settings)).responses(modelID)
 }
 

packages/ai/src/providers/xai.ts

@@ -1,5 +1,5 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { Route, type RouteDefaultsInput, type CompactOperation } from "../route/client.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
 import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
@@ -13,7 +13,7 @@ import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
 
-export type XAIProviderOptionsInput = OpenAIOptionsInput & { readonly contextManagement?: never }
+export type XAIProviderOptionsInput = OpenAIOptionsInput
 
 export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
   ProviderAuthOption<"optional"> & {
@@ -32,7 +32,6 @@ export type { XAIImageOptions } from "../protocols/xai-images.js"
 const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
 
 const responsesRoute = Route.make({
-  compact: XAIResponses.compact,
   id: "openai-responses",
   provider: id,
   providerMetadataKey: "xai",
@@ -103,10 +102,7 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput, CompactOperation>["model"] = (
-  modelID,
-  settings,
-) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
     apiKey: settings.apiKey,
     baseURL: settings.baseURL,

packages/ai/src/route/client.ts

@@ -13,7 +13,6 @@ import * as ProviderShared from "../protocols/shared.js"
 import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
   AIError,
-  CompactionResponse,
   AIErrorReason,
   GenerationOptions,
   HttpOptions,
@@ -35,12 +34,7 @@ export interface RouteBody<Body> {
   readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>
 }
 
-export interface Route<
-  Body,
-  Prepared = unknown,
-  Compact extends CompactOperation | undefined = CompactOperation | undefined,
-> {
-  readonly compact: Compact
+export interface Route<Body, Prepared = unknown> {
   readonly id: string
   readonly provider?: ProviderID
   /** ProviderMetadata namespace emitted and consumed by this route. */
@@ -48,15 +42,13 @@ export interface Route<
   readonly protocol: ProtocolID
   readonly endpoint: Endpoint.Definition<Body>
   readonly auth: Auth.Definition
-  /** Deployment headers resolved once for every operation, before transport authentication. */
-  readonly headers?: (input: { readonly request: LLMRequest }) => Record<string, string>
   readonly transport: Transport<Body, Prepared, unknown>
   readonly defaults: RouteDefaults
   readonly body: RouteBody<Body>
-  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared, Compact>
+  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
   readonly model: <Options extends ProviderOptions = ProviderOptions>(
     input: RouteMappedLanguageModelInput,
-  ) => LanguageModel<Options, Compact>
+  ) => LanguageModel<Options>
   readonly prepareTransport: (
     body: Body,
     request: LLMRequest,
@@ -74,11 +66,7 @@ export interface Route<
 // Normal call sites use `OpenAIChat.route`; callers only need body types
 // when preparing a request with a protocol-specific type assertion.
 // oxlint-disable-next-line typescript-eslint/no-explicit-any
-export type AnyRoute<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Route<
-  any,
-  any,
-  Compact
->
+export type AnyRoute = Route<any, any>
 
 export type HttpOptionsInput = HttpOptions.Input
 
@@ -111,15 +99,15 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
 
 type RouteMappedLanguageModelInput = RouteLanguageModelInput | RouteRoutedLanguageModelInput
 
-const makeRouteLanguageModel = <Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-  route: AnyRoute<Compact>,
+const makeRouteLanguageModel = <Options extends ProviderOptions = ProviderOptions>(
+  route: AnyRoute,
   mapped: RouteMappedLanguageModelInput,
 ) => {
   const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
   if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
   if (!endpointBaseURL(route.endpoint))
     throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return LanguageModel.make<Options, Compact>({
+  return LanguageModel.make<Options>({
     ...mapped,
     provider,
     route,
@@ -162,10 +150,6 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }
 
 export interface Interface {
-  readonly compact: (
-    request: CompactionRequest,
-    options?: Pick<StreamOptions, "http">,
-  ) => Effect.Effect<CompactionResponse, AIError>
   readonly stream: StreamMethod
   readonly generate: GenerateMethod
 }
@@ -183,19 +167,6 @@ export interface GenerateMethod {
   (request: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError>
 }
 
-export type CompactOperation = (
-  request: LLMRequest,
-  executor: RequestExecutor.Interface,
-  options?: Pick<StreamOptions, "http">,
-) => Effect.Effect<CompactionResponse, AIError>
-
-export type CompactionRequest = LLMRequest & {
-  readonly model: LanguageModel<ProviderOptions, CompactOperation>
-}
-
-export const canCompact = (request: LLMRequest): request is CompactionRequest =>
-  request.model.route.compact !== undefined
-
 export class Service extends Context.Service<Service, Interface>()("@opencode/LLMClient") {}
 
 const resolveRequestOptions = (request: LLMRequest) => {
@@ -216,7 +187,6 @@ const resolveRequestOptions = (request: LLMRequest) => {
 }
 
 export interface MakeInput<Body, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -238,7 +208,6 @@ export interface MakeInput<Body, Frame, Event, State> {
 }
 
 export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
-  readonly compact?: CompactOperation
   /** Route id used in diagnostics and prepared request metadata. */
   readonly id: string
   /** Provider identity for route-owned model construction. */
@@ -314,14 +283,12 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
 
   const build = (routeInput: BuiltRouteInput): Route<Body, Prepared> => {
     const route: Route<Body, Prepared> = {
-      compact: routeInput.compact,
       id: routeInput.id,
       provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
       providerMetadataKey: routeInput.providerMetadataKey,
       protocol: protocol.id,
       endpoint: routeInput.endpoint,
       auth: routeInput.auth ?? Auth.none,
-      headers: routeInput.headers,
       transport: routeInput.transport,
       defaults: routeInput.defaults ?? {},
       body: protocol.body,
@@ -343,7 +310,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
         })
       },
       model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedLanguageModelInput) =>
-        makeRouteLanguageModel<Options, CompactOperation | undefined>(route, input),
+        makeRouteLanguageModel<Options>(route, input),
       prepareTransport: (body, request, options) =>
         routeInput.transport.prepare({
           body,
@@ -351,6 +318,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
           endpoint: routeInput.endpoint,
           auth: routeInput.auth ?? Auth.none,
           encodeBody,
+          headers: routeInput.headers,
           middleware: options?.http,
           webSocket: options?.webSocket,
         }),
@@ -440,12 +408,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
   return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) })
 }
 
-export function make<Body, Prepared, Frame, Event, State>(
-  input: MakeTransportInput<Body, Prepared, Frame, Event, State> & { readonly compact: CompactOperation },
-): Route<Body, Prepared, CompactOperation>
-export function make<Body, Frame, Event, State>(
-  input: MakeInput<Body, Frame, Event, State> & { readonly compact: CompactOperation },
-): Route<Body, HttpTransport.HttpPrepared<Frame>, CompactOperation>
 export function make<Body, Prepared, Frame, Event, State>(
   input: MakeTransportInput<Body, Prepared, Frame, Event, State>,
 ): Route<Body, Prepared>
@@ -473,7 +435,6 @@ export function make<Body, Prepared, Frame, Event, State>(
   if ("transport" in input) return makeFromTransport(input)
   const protocol = input.protocol
   return makeFromTransport({
-    compact: input.compact,
     id: input.id,
     provider: input.provider,
     providerMetadataKey: input.providerMetadataKey,
@@ -486,23 +447,11 @@ export function make<Body, Prepared, Frame, Event, State>(
   })
 }
 
-const prepareRequest = (request: LLMRequest) => {
-  const original = resolveRequestOptions(request)
-  const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
-  // Deduplicate per sibling level; a tool and a namespace may share a name.
-  const dedupe = (tools: LLMRequest["tools"]): LLMRequest["tools"] =>
-    [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) =>
-      tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) },
-    )
-  const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }))
-  const headers = resolved.model.route.headers?.({ request: resolved })
-  return headers === undefined
-    ? resolved
-    : LLMRequest.update(resolved, { http: mergeHttpOptions(new HttpOptions({ headers }), resolved.http) })
-}
-
 const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest, options?: StreamOptions) {
-  const resolved = prepareRequest(request)
+  const original = applyCachePolicy(resolveRequestOptions(request))
+  const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }))
+  const tools = [...new Map(sanitized.tools.map((tool) => [tool.name, tool])).values()]
+  const resolved = tools.length === sanitized.tools.length ? sanitized : LLMRequest.update(sanitized, { tools })
   const route = resolved.model.route
 
   const body = yield* route.body
@@ -561,15 +510,6 @@ export function generate(request: LLMRequest, options?: StreamOptions): Effect.E
   })
 }
 
-export const compact = (
-  request: CompactionRequest,
-  options?: Pick<StreamOptions, "http">,
-): Effect.Effect<CompactionResponse, AIError, Service> =>
-  Effect.gen(function* () {
-    const client = yield* Service
-    return yield* client.compact(request, options)
-  })
-
 export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
   Stream.unwrap(
     Effect.gen(function* () {
@@ -580,32 +520,16 @@ export const streamRequest = (request: LLMRequest, options?: StreamOptions) =>
 export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const executor = yield* RequestExecutor.Service
-    const stream = streamRequestWith({ http: executor })
-    return Service.of({
-      stream,
-      generate: generateWith(stream),
-      compact: (request, options) =>
-        Effect.suspend(() => {
-          const operation = request.model.route.compact
-          if (!operation)
-            return ProviderShared.unsupportedOperation({
-              operation: "compact",
-              provider: request.model.provider,
-              route: request.model.route.id,
-              message: `${request.model.provider}/${request.model.route.id} does not support explicit compaction`,
-            })
-          return operation(prepareRequest(request), executor, options)
-        }),
+    const stream = streamRequestWith({
+      http: yield* RequestExecutor.Service,
     })
+    return Service.of({ stream, generate: generateWith(stream) })
   }),
 )
 
 export const Route = { make } as const
 
 export const LLMClient = {
-  canCompact,
-  compact,
   Service,
   layer,
   stream,

packages/ai/src/schema/errors.ts

@@ -35,21 +35,6 @@ export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>
   },
 ) {}
 
-/**
- * A caller-requested operation the selected route does not implement, such as
- * explicit compaction on a route without a compact endpoint. Detected locally
- * before any network I/O, so unlike transport or provider-output failures it
- * never carries HTTP context from a provider round-trip.
- */
-export class UnsupportedOperationError extends Schema.TaggedError<UnsupportedOperationError>(
-  "AI.Error.UnsupportedOperation",
-)("UnsupportedOperation", {
-  ...ReasonFields,
-  operation: Schema.String,
-  provider: Schema.optional(ProviderID),
-  route: Schema.optional(RouteID),
-}) {}
-
 export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
   ...ReasonFields,
   route: RouteID,
@@ -122,7 +107,6 @@ export class UnknownProviderError extends Schema.TaggedError<UnknownProviderErro
 
 export const AIErrorReason = Schema.Union([
   InvalidRequestError,
-  UnsupportedOperationError,
   NoRouteError,
   AuthenticationError,
   RateLimitError,

packages/ai/src/schema/events.ts

@@ -3,7 +3,6 @@ import { LLM } from "@opencode-ai/schema/llm"
 import { ContentBlockID, ToolCallID } from "./ids.js"
 import {
   Message,
-  CompactionPart,
   ProviderMetadata,
   ToolCallPart,
   ToolOutput,
@@ -63,8 +62,6 @@ export { ProviderMetadata } from "./messages.js"
  * Matches the same escape-hatch field on `LLMEvent`.
  */
 export class Usage extends Schema.Class<Usage>("AI.Usage")({
-  /** Effective input size of the final message iteration, when reported; not billed totals. */
-  contextTokens: Schema.optional(Schema.Number),
   inputTokens: Schema.optional(Schema.Number),
   outputTokens: Schema.optional(Schema.Number),
   nonCachedInputTokens: Schema.optional(Schema.Number),
@@ -75,7 +72,7 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
   providerMetadata: Schema.optional(ProviderMetadata),
 }) {
   /**
-   * Non-reasoning output tokens (including compaction summaries) — `outputTokens` minus `reasoningTokens`, clamped
+   * Visible output tokens — `outputTokens` minus `reasoningTokens`, clamped
    * to zero. The one place subtraction happens in this contract; the clamp
    * means a provider reporting `reasoningTokens > outputTokens` produces a
    * harmless zero rather than a negative that crashes downstream schemas.
@@ -91,12 +88,6 @@ export class Usage extends Schema.Class<Usage>("AI.Usage")({
 
 export type UsageInput = Usage | ConstructorParameters<typeof Usage>[0]
 
-/** A replacement context window, not an assistant message to append to prior history. */
-export class CompactionResponse extends Schema.Class<CompactionResponse>("LLM.CompactionResponse")({
-  replacement: Schema.Array(Message),
-  usage: Schema.optional(Usage),
-}) {}
-
 export const StepStart = Schema.Struct({
   type: Schema.tag("step-start"),
   index: Schema.Number,
@@ -155,7 +146,6 @@ export const ToolInputStart = Schema.Struct({
   type: Schema.tag("tool-input-start"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
@@ -165,7 +155,6 @@ export const ToolInputDelta = Schema.Struct({
   type: Schema.tag("tool-input-delta"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   text: Schema.String,
   /** Best-effort parse of all input fragments received through this delta. */
   input: Schema.optional(Schema.Unknown),
@@ -176,7 +165,6 @@ export const ToolInputEnd = Schema.Struct({
   type: Schema.tag("tool-input-end"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>
@@ -186,7 +174,6 @@ export const ToolInputError = Schema.Struct({
   type: Schema.tag("tool-input-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   raw: Schema.String,
 }).annotate({ identifier: "LLM.Event.ToolInputError" })
 export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
@@ -195,7 +182,6 @@ export const ToolCall = Schema.Struct({
   type: Schema.tag("tool-call"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   input: Schema.Unknown,
   providerExecuted: Schema.optional(Schema.Boolean),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -206,7 +192,6 @@ export const ToolResult = Schema.Struct({
   type: Schema.tag("tool-result"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   result: ToolResultValue,
   output: Schema.optional(ToolOutput),
   providerExecuted: Schema.optional(Schema.Boolean),
@@ -218,7 +203,6 @@ export const ToolError = Schema.Struct({
   type: Schema.tag("tool-error"),
   id: ToolCallID,
   name: Schema.String,
-  namespace: Schema.optional(Schema.String),
   message: Schema.String,
   error: Schema.optional(Schema.Defect()),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -257,7 +241,6 @@ export const ProviderErrorEvent = Schema.Struct({
 export type ProviderErrorEvent = Schema.Schema.Type<typeof ProviderErrorEvent>
 
 const llmEventTagged = Schema.Union([
-  CompactionPart,
   StepStart,
   TextStart,
   TextDelta,
@@ -291,7 +274,6 @@ const toolCallID = (value: ToolCallID | string) => ToolCallID.make(value)
  * `events.filter(LLMEvent.guards["tool-call"])`.
  */
 export const LLMEvent = Object.assign(llmEventTagged, {
-  compaction: CompactionPart.make,
   stepStart: StepStart.make,
   textStart: (input: WithID<TextStart, ContentBlockID>) => TextStart.make({ ...input, id: contentBlockID(input.id) }),
   textDelta: (input: WithID<TextDelta, ContentBlockID>) => TextDelta.make({ ...input, id: contentBlockID(input.id) }),
@@ -329,7 +311,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
     }),
   providerError: ProviderErrorEvent.make,
   is: {
-    compaction: llmEventTagged.guards.compaction,
     stepStart: llmEventTagged.guards["step-start"],
     textStart: llmEventTagged.guards["text-start"],
     textDelta: llmEventTagged.guards["text-delta"],
@@ -352,10 +333,10 @@ export const LLMEvent = Object.assign(llmEventTagged, {
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>
 
 /** Joins deltas per fragment, letting an authoritative end value replace that fragment's accumulated deltas. */
-const joinFragments = (
+const joinFragments = <Delta extends { id: string; text: string }, End extends { id: string; text?: string }>(
   events: ReadonlyArray<LLMEvent>,
-  isDelta: (event: LLMEvent) => event is LLMEvent & { id: string; text: string },
-  isEnd: (event: LLMEvent) => event is LLMEvent & { id: string; text?: string },
+  isDelta: (event: LLMEvent) => event is Extract<LLMEvent, Delta>,
+  isEnd: (event: LLMEvent) => event is Extract<LLMEvent, End>,
 ) => {
   const order: string[] = []
   const parts = new Map<string, string>()
@@ -392,7 +373,6 @@ interface ContentAssembly {
 
 interface ToolInputAssembly {
   readonly name: string
-  readonly namespace?: string
   readonly text: string
   readonly providerMetadata?: ProviderMetadata
 }
@@ -530,17 +510,12 @@ const reduceToolInputStart = (state: ResponseState, event: ToolInputStart): Resp
   ...state,
   toolInputs: {
     ...state.toolInputs,
-    [event.id]: {
-      name: event.name,
-      namespace: event.namespace,
-      text: "",
-      providerMetadata: event.providerMetadata,
-    },
+    [event.id]: { name: event.name, text: "", providerMetadata: event.providerMetadata },
   },
 })
 
 const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: { ...state.toolInputs, [event.id]: { ...current, text: current.text + event.text } },
@@ -548,7 +523,7 @@ const reduceToolInputDelta = (state: ResponseState, event: ToolInputDelta): Resp
 }
 
 const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): ResponseState => {
-  const current = state.toolInputs[event.id] ?? { name: event.name, namespace: event.namespace, text: "" }
+  const current = state.toolInputs[event.id] ?? { name: event.name, text: "" }
   return {
     ...state,
     toolInputs: {
@@ -556,7 +531,6 @@ const reduceToolInputEnd = (state: ResponseState, event: ToolInputEnd): Response
       [event.id]: {
         ...current,
         name: event.name,
-        namespace: event.namespace,
         providerMetadata: event.providerMetadata ?? current.providerMetadata,
       },
     },
@@ -567,7 +541,6 @@ const toolCallContent = (event: ToolCall): ContentPart =>
   ToolCallPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     input: event.input,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),
@@ -577,7 +550,6 @@ const toolResultContent = (event: ToolResult): ContentPart =>
   ToolResultPart.make({
     id: event.id,
     name: event.name,
-    namespace: event.namespace,
     result: event.result,
     ...(event.providerExecuted === undefined ? {} : { providerExecuted: event.providerExecuted }),
     ...(event.providerMetadata === undefined ? {} : { providerMetadata: event.providerMetadata }),
@@ -591,8 +563,6 @@ const reduceToolCall = (state: ResponseState, event: ToolCall): ResponseState =>
 const reduceResponseState = (state: ResponseState, event: LLMEvent): ResponseState => {
   const next = appendEvent(state, event)
   switch (event.type) {
-    case "compaction":
-      return appendContent(next, event)
     case "text-start":
       return ensureText(next, event.id, event.providerMetadata)
     case "text-delta":

packages/ai/src/schema/messages.ts

@@ -7,10 +7,8 @@ import {
   HttpOptions,
   JsonSchema,
   LanguageModelSchema,
-  type LanguageModel,
   ProviderOptions,
 } from "./options.js"
-import { ProviderID } from "./ids.js"
 
 export const MessageRole = Schema.Literals(["system", "user", "assistant", "tool"])
 export type MessageRole = Schema.Schema.Type<typeof MessageRole>
@@ -54,7 +52,6 @@ export const MediaPart = Schema.Struct({
   filename: Schema.optional(Schema.String),
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Content.Media" })
 export type MediaPart = Schema.Schema.Type<typeof MediaPart>
 
@@ -135,7 +132,6 @@ export const ToolCallPart = Object.assign(
     type: Schema.Literal("tool-call"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     input: Schema.Unknown,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -153,7 +149,6 @@ export const ToolResultPart = Object.assign(
     type: Schema.Literal("tool-result"),
     id: Schema.String,
     name: Schema.String,
-    namespace: Schema.optional(Schema.String),
     result: ToolResultValue,
     providerExecuted: Schema.optional(Schema.Boolean),
     cache: Schema.optional(CacheHint),
@@ -170,7 +165,6 @@ export const ToolResultPart = Object.assign(
       type: "tool-result",
       id: input.id,
       name: input.name,
-      namespace: input.namespace,
       result: ToolResultValue.make(input.result, input.resultType),
       providerExecuted: input.providerExecuted,
       cache: input.cache,
@@ -191,40 +185,9 @@ export const ReasoningPart = Schema.Struct({
 }).annotate({ identifier: "LLM.Content.Reasoning" })
 export type ReasoningPart = Schema.Schema.Type<typeof ReasoningPart>
 
-/** A provider-generated context checkpoint, distinct from visible assistant text. */
-type CompactionContent =
-  | { readonly encrypted: string; readonly text?: never }
-  | { readonly text: string | null; readonly encrypted?: never }
-
-const compactionPartSchema = Schema.Struct({
-  type: Schema.Literal("compaction"),
-  provider: ProviderID,
-  id: Schema.optional(Schema.String),
-  encrypted: Schema.optional(Schema.String),
-  /** Null means the provider failed to produce a summary; prior history must be retained. */
-  text: Schema.optional(Schema.NullOr(Schema.String)),
-})
-  .pipe(
-    Schema.refine(
-      (part): part is typeof part & CompactionContent => (part.encrypted !== undefined) !== (part.text !== undefined),
-      { message: "Compaction requires either encrypted content or a summary" },
-    ),
-  )
-  .annotate({ identifier: "LLM.Content.Compaction" })
-export type CompactionPart = typeof compactionPartSchema.Type
-export const CompactionPart = Object.assign(compactionPartSchema, {
-  make: (input: Omit<CompactionPart, "type" | "encrypted" | "text"> & CompactionContent): CompactionPart =>
-    Schema.decodeUnknownSync(compactionPartSchema)({ type: "compaction", ...input }),
-})
-
-export const ContentPart = Schema.Union([
-  TextPart,
-  MediaPart,
-  ToolCallPart,
-  ToolResultPart,
-  ReasoningPart,
-  CompactionPart,
-]).pipe(Schema.toTaggedUnion("type"))
+export const ContentPart = Schema.Union([TextPart, MediaPart, ToolCallPart, ToolResultPart, ReasoningPart]).pipe(
+  Schema.toTaggedUnion("type"),
+)
 export type ContentPart = Schema.Schema.Type<typeof ContentPart>
 
 export class Message extends Schema.Class<Message>("LLM.Message")({
@@ -232,7 +195,6 @@ export class Message extends Schema.Class<Message>("LLM.Message")({
   role: MessageRole,
   content: Schema.Array(ContentPart),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-  providerMetadata: Schema.optional(ProviderMetadata),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {}
 
@@ -269,7 +231,7 @@ export namespace Message {
     make({ role: "tool", content: ["type" in result ? result : ToolResultPart.make(result)] })
 }
 
-const toolDefinitionFields = {
+export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
   name: Schema.String,
   description: Schema.String,
   inputSchema: JsonSchema,
@@ -277,71 +239,15 @@ const toolDefinitionFields = {
   cache: Schema.optional(CacheHint),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
   native: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}
-
-export type ToolDefinitionInput = Schema.Struct.Type<typeof toolDefinitionFields>
-
-export class ToolDefinition extends Schema.Class<ToolDefinition>("LLM.ToolDefinition")({
-  type: Schema.Literal("tool"),
-  ...toolDefinitionFields,
-}) {
-  constructor(input: ToolDefinitionInput) {
-    super({ ...input, type: "tool" })
-  }
-}
+}) {}
 
 export namespace ToolDefinition {
-  export type Input = ToolDefinition | ToolDefinitionInput
+  export type Input = ToolDefinition | ConstructorParameters<typeof ToolDefinition>[0]
 
   /** Normalize tool definition input into the canonical `ToolDefinition` class. */
   export const make = (input: Input) => (input instanceof ToolDefinition ? input : new ToolDefinition(input))
 }
 
-export type ToolNamespace = {
-  readonly type: "namespace"
-  readonly name: string
-  readonly description?: string
-  readonly tools: ReadonlyArray<ToolEntry>
-}
-
-export type ToolNamespaceInput = Omit<ToolNamespace, "type" | "tools"> & {
-  readonly tools: ReadonlyArray<ToolEntryInput>
-}
-export type ToolNamespaceEntryInput = ToolNamespaceInput & { readonly type: "namespace" }
-
-export const ToolNamespace: Schema.Codec<ToolNamespace> & {
-  readonly make: (input: ToolNamespace | ToolNamespaceInput) => ToolNamespace
-} = Object.assign(
-  Schema.Struct({
-    type: Schema.Literal("namespace"),
-    name: Schema.String,
-    description: Schema.optional(Schema.UndefinedOr(Schema.String)),
-    tools: Schema.Array(Schema.suspend((): Schema.Codec<ToolEntry> => ToolEntry)),
-  }).annotate({ identifier: "LLM.ToolNamespace" }),
-  {
-    make: (input: ToolNamespace | ToolNamespaceInput): ToolNamespace => ({
-      ...input,
-      type: "namespace",
-      tools: input.tools.map(ToolEntry.make),
-    }),
-  },
-)
-
-export type ToolEntry = ToolDefinition | ToolNamespace
-export type ToolEntryInput = ToolDefinition.Input | ToolNamespaceEntryInput
-export const ToolEntry: Schema.Codec<ToolEntry> & {
-  readonly make: (input: ToolEntryInput) => ToolEntry
-} = Object.assign(
-  Schema.Union([ToolDefinition, ToolNamespace]).pipe(
-    Schema.toTaggedUnion("type"),
-    Schema.annotate({ identifier: "LLM.ToolEntry" }),
-  ),
-  {
-    make: (input: ToolEntryInput): ToolEntry =>
-      "type" in input && input.type === "namespace" ? ToolNamespace.make(input) : ToolDefinition.make(input),
-  },
-)
-
 export class ToolChoice extends Schema.Class<ToolChoice>("LLM.ToolChoice")({
   type: Schema.Literals(["auto", "none", "required", "tool"]),
   name: Schema.optional(Schema.String),
@@ -366,12 +272,12 @@ export namespace ToolChoice {
   }
 }
 
-const requestSchema = Schema.Struct({
+export class LLMRequest extends Schema.Class<LLMRequest>("LLM.Request")({
   id: Schema.optional(Schema.String),
   model: LanguageModelSchema,
   system: Schema.Array(SystemPart),
   messages: Schema.Array(Message),
-  tools: Schema.Array(ToolEntry),
+  tools: Schema.Array(ToolDefinition),
   toolChoice: Schema.optional(ToolChoice),
   generation: Schema.optional(GenerationOptions),
   providerOptions: Schema.optional(ProviderOptions),
@@ -380,26 +286,12 @@ const requestSchema = Schema.Struct({
   // Stable cache affinity for protocols that support provider-managed prompt caching.
   promptCacheKey: Schema.optional(Schema.String),
   metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-})
-
-export class LLMRequest<Model extends LanguageModel = LanguageModel> extends Schema.Class<LLMRequest>("LLM.Request")(
-  requestSchema.fields,
-) {
-  declare readonly model: Model
-
-  // Preserve model inference instead of inheriting the schema's erased constructor signature.
-  // oxlint-disable-next-line no-useless-constructor
-  constructor(input: LLMRequest.Input<Model>) {
-    super(input)
-  }
-}
+}) {}
 
 export namespace LLMRequest {
-  export type Input<Model extends LanguageModel = LanguageModel> = Omit<typeof requestSchema.Type, "model"> & {
-    readonly model: Model
-  }
+  export type Input = ConstructorParameters<typeof LLMRequest>[0]
 
-  export const input = <Model extends LanguageModel>(request: LLMRequest<Model>): Input<Model> => ({
+  export const input = (request: LLMRequest): Input => ({
     id: request.id,
     model: request.model,
     system: request.system,
@@ -414,16 +306,7 @@ export namespace LLMRequest {
     metadata: request.metadata,
   })
 
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest,
-    patch: Partial<Input<Model>> & { readonly model: Model },
-  ): LLMRequest<Model>
-  export function update<Model extends LanguageModel>(
-    request: LLMRequest<Model>,
-    patch: Partial<Omit<Input, "model">> & { readonly model?: undefined },
-  ): LLMRequest<Model>
-  export function update(request: LLMRequest, patch: Partial<Input>): LLMRequest
-  export function update(request: LLMRequest, patch: Partial<Input>) {
+  export const update = (request: LLMRequest, patch: Partial<Input>) => {
     if (Object.keys(patch).length === 0) return request
     return new LLMRequest({
       ...input(request),

packages/ai/src/schema/options.ts

@@ -1,6 +1,6 @@
 import { Schema } from "effect"
 import { ModelID, ProviderID } from "./ids.js"
-import type { AnyRoute, CompactOperation } from "../route/client.js"
+import type { AnyRoute } from "../route/client.js"
 import { isRecord } from "../utils/record.js"
 
 export const JsonSchema = Schema.Record(Schema.String, Schema.Unknown)
@@ -173,18 +173,15 @@ export namespace LanguageModelCompatibility {
     input instanceof LanguageModelCompatibility ? input : new LanguageModelCompatibility(input)
 }
 
-export class LanguageModel<
-  Options extends ProviderOptions = ProviderOptions,
-  Compact extends CompactOperation | undefined = CompactOperation | undefined,
-> {
+export class LanguageModel<Options extends ProviderOptions = ProviderOptions> {
   declare protected readonly _ProviderOptions: Options
   readonly id: ModelID
   readonly provider: ProviderID
-  readonly route: AnyRoute<Compact>
+  readonly route: AnyRoute
   readonly defaults?: LanguageModelDefaults
   readonly compatibility?: LanguageModelCompatibility
 
-  constructor(input: LanguageModel.ConstructorInput<Compact>) {
+  constructor(input: LanguageModel.ConstructorInput) {
     this.id = input.id
     this.provider = input.provider
     this.route = input.route
@@ -192,11 +189,8 @@ export class LanguageModel<
     this.compatibility = input.compatibility
   }
 
-  static make<
-    Options extends ProviderOptions = ProviderOptions,
-    Compact extends CompactOperation | undefined = CompactOperation | undefined,
-  >(input: LanguageModel.Input<Compact>) {
-    return new LanguageModel<Options, Compact>({
+  static make<Options extends ProviderOptions = ProviderOptions>(input: LanguageModel.Input) {
+    return new LanguageModel<Options>({
       id: ModelID.make(input.id),
       provider: ProviderID.make(input.provider),
       route: input.route,
@@ -206,9 +200,7 @@ export class LanguageModel<
     })
   }
 
-  static input<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options, Compact>,
-  ): LanguageModel.ConstructorInput<Compact> {
+  static input<Options extends ProviderOptions>(model: LanguageModel<Options>): LanguageModel.ConstructorInput {
     return {
       id: model.id,
       provider: model.provider,
@@ -218,41 +210,25 @@ export class LanguageModel<
     }
   }
 
-  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input<Compact>> & { readonly route: AnyRoute<Compact> },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions, Compact extends CompactOperation | undefined>(
-    model: LanguageModel<Options, Compact>,
-    patch: Partial<Omit<LanguageModel.Input, "route">> & { readonly route?: undefined },
-  ): LanguageModel<Options, Compact>
-  static update<Options extends ProviderOptions>(
-    model: LanguageModel<Options>,
-    patch: Partial<LanguageModel.Input>,
-  ): LanguageModel<Options>
   static update<Options extends ProviderOptions>(model: LanguageModel<Options>, patch: Partial<LanguageModel.Input>) {
     if (Object.keys(patch).length === 0) return model
     return LanguageModel.make<Options>({
       ...LanguageModel.input(model),
       ...patch,
-      route: patch.route ?? model.route,
     })
   }
 }
 
 export namespace LanguageModel {
-  export type ConstructorInput<Compact extends CompactOperation | undefined = CompactOperation | undefined> = {
+  export type ConstructorInput = {
     readonly id: ModelID
     readonly provider: ProviderID
-    readonly route: AnyRoute<Compact>
+    readonly route: AnyRoute
     readonly defaults?: LanguageModelDefaults
     readonly compatibility?: LanguageModelCompatibility
   }
 
-  export type Input<Compact extends CompactOperation | undefined = CompactOperation | undefined> = Omit<
-    ConstructorInput<Compact>,
-    "id" | "provider" | "defaults" | "compatibility"
-  > & {
+  export type Input = Omit<ConstructorInput, "id" | "provider" | "defaults" | "compatibility"> & {
     readonly id: string | ModelID
     readonly provider: string | ProviderID
     readonly defaults?: LanguageModelDefaults.Input

packages/ai/src/testing.ts

@@ -4,7 +4,6 @@ import { LLMClient } from "./route/client.js"
 import {
   LLMEvent,
   LLMResponse,
-  CompactionResponse,
   type FinishReasonDetails,
   type AIError,
   type LLMRequest,
@@ -13,7 +12,7 @@ import {
 } from "./schema/index.js"
 import { Context, Deferred, Effect, Latch, Layer, Queue, Scope, Stream } from "effect"
 
-export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError> | CompactionResponse
+export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>
 
 export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>
 
@@ -100,6 +99,8 @@ export const failAfter = (error: AIError, ...events: readonly LLMEvent[]) =>
 
 export const hangAfter = (...events: readonly LLMEvent[]) => Stream.concat(Stream.fromIterable(events), Stream.never)
 
+const toStream = (response: Response) => (Stream.isStream(response) ? response : Stream.fromIterable(response))
+
 const make = (options: LayerOptions) =>
   Effect.sync(() => {
     const requests: LLMRequest[] = []
@@ -112,41 +113,26 @@ const make = (options: LayerOptions) =>
         requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
       )
 
-    const take = (request: LLMRequest) =>
-      Effect.suspend(() => {
+    const stream: ClientInterface["stream"] = (request) =>
+      Stream.suspend(() => {
         const count = requests.push(options.transformRequest?.(request) ?? request)
         const waiting = started
         started = Deferred.makeUnsafe()
         const gate = activeGate
         try {
           const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback)
-          if (!response) return Effect.die(new Error(`TestLLM has no response for request ${count}`))
-          if (!gate) return Effect.succeed(response)
-          return Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(response))
+          if (!response) return Stream.die(new Error(`TestLLM has no response for request ${count}`))
+          const streamed = toStream(response)
+          if (!gate) return streamed
+          return Stream.unwrap(
+            Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
+          )
         } finally {
           // Waiters can resume synchronously; assign the reply and gate before notifying them.
           Deferred.doneUnsafe(waiting, Effect.void)
         }
       })
-    const stream: ClientInterface["stream"] = (request) =>
-      Stream.unwrap(
-        take(request).pipe(
-          Effect.map((response) => {
-            if (response instanceof CompactionResponse)
-              return Stream.die("TestLLM generation requires an event response")
-            return Stream.isStream(response) ? response : Stream.fromIterable(response)
-          }),
-        ),
-      )
     const test = Test.of({
-      compact: (request) =>
-        take(request).pipe(
-          Effect.flatMap((response) =>
-            response instanceof CompactionResponse
-              ? Effect.succeed(response)
-              : Effect.die("TestLLM compaction requires a CompactionResponse"),
-          ),
-        ),
       stream,
       generate: (request) =>
         stream(request).pipe(

packages/ai/src/tool-history.ts

@@ -37,13 +37,7 @@ function missingToolResults(calls: Iterable<ToolCallPart>) {
   return new Message({
     role: "tool",
     content: [...calls].map((call) =>
-      ToolResultPart.make({
-        id: call.id,
-        name: call.name,
-        namespace: call.namespace,
-        result: MISSING_TOOL_RESULT,
-        resultType: "error",
-      }),
+      ToolResultPart.make({ id: call.id, name: call.name, result: MISSING_TOOL_RESULT, resultType: "error" }),
     ),
   })
 }
@@ -53,7 +47,7 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
     if (part.type !== "tool-result" || part.providerExecuted === true) return part
     const call = pending.get(part.id)
     if (call) pending.delete(part.id)
-    return normalizeToolResult(part, call)
+    return normalizeToolResult(part, call?.name ?? part.name)
   })
   if (content.length === 0) return undefined
   if (content.every((part, index) => part === message.content[index])) return message
@@ -62,16 +56,12 @@ function normalizeToolMessage(message: Message, pending: Map<string, ToolCallPar
     role: message.role,
     content,
     metadata: message.metadata,
-    providerMetadata: message.providerMetadata,
     native: message.native,
   })
 }
 
-function normalizeToolResult(part: ToolResultPart, call: ToolCallPart | undefined): ToolResultPart {
-  const named =
-    call === undefined || (part.name === call.name && part.namespace === call.namespace)
-      ? part
-      : { ...part, name: call.name, namespace: call.namespace }
+function normalizeToolResult(part: ToolResultPart, name: string): ToolResultPart {
+  const named = part.name === name ? part : { ...part, name }
   if (named.result.type === "text" && named.result.value === "")
     return { ...named, result: { type: "text", value: EMPTY_TOOL_OUTPUT } }
   if (named.result.type === "error" && named.result.value === "")

packages/ai/src/tool-runtime.ts

@@ -21,11 +21,10 @@ export interface DispatchResult extends ToolSettlement {
 
 /** Execute one canonical tool call without owning provider IO or continuation. */
 export const dispatch = (tools: Tools, call: ToolCallPart): Effect.Effect<DispatchResult> => {
-  const name = call.namespace === undefined ? call.name : `${call.namespace}.${call.name}`
-  const tool = tools[name]
-  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${name}` }))
+  const tool = tools[call.name]
+  if (!tool) return Effect.succeed(result(call, { type: "error", value: `Unknown tool: ${call.name}` }))
   if (!tool.execute)
-    return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${name}` }))
+    return Effect.succeed(result(call, { type: "error", value: `Tool has no execute handler: ${call.name}` }))
 
   return decodeAndExecute(tool, call).pipe(
     Effect.map((value) => result(call, value)),
@@ -39,11 +38,7 @@ const decodeAndExecute = (tool: AnyTool, call: ToolCallPart): Effect.Effect<Tool
   tool._decode(call.input).pipe(
     Effect.mapError((error) => new ToolFailure({ message: `Invalid tool input: ${error.message}` })),
     Effect.flatMap((decoded) =>
-      tool.execute!(decoded, {
-        id: call.id,
-        name: call.name,
-        namespace: call.namespace,
-      }).pipe(
+      tool.execute!(decoded, { id: call.id, name: call.name }).pipe(
         Effect.flatMap((value) =>
           tool._encode(value).pipe(
             Effect.mapError(
@@ -76,7 +71,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolError({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               message: String(settlement.result.value),
               error,
               providerMetadata: call.providerMetadata,
@@ -84,7 +78,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               providerMetadata: call.providerMetadata,
             }),
@@ -93,7 +86,6 @@ const result = (call: ToolCallPart, value: ToolResultValueType | ToolSettlement,
             LLMEvent.toolResult({
               id: call.id,
               name: call.name,
-              namespace: call.namespace,
               result: settlement.result,
               output: settlement.output,
               providerMetadata: call.providerMetadata,

packages/ai/src/tool.ts

@@ -16,7 +16,6 @@ export type ToolSchema<T> = Schema.Codec<T, any, never, never>
 export interface ToolExecuteContext {
   readonly id: ToolCallPart["id"]
   readonly name: ToolCallPart["name"]
-  readonly namespace?: ToolCallPart["namespace"]
 }
 
 export type ToolExecute<Parameters extends ToolSchema<any>, Success extends ToolSchema<any>> = (

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

@@ -215,35 +215,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  it.effect("deduplicates tools before counting cache hints", () =>
-    Effect.gen(function* () {
-      const manual = new CacheHint({ type: "ephemeral" })
-      const duplicate = (description: string) => ({
-        name: "lookup",
-        description,
-        inputSchema: { type: "object" },
-        cache: manual,
-      })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: anthropicModel,
-          tools: [
-            duplicate("first"),
-            duplicate("second"),
-            duplicate("third"),
-            duplicate("fourth"),
-            { name: "lookup", description: "final", inputSchema: { type: "object" } },
-          ],
-          cache: { tools: true },
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        expect.objectContaining({ name: "lookup", description: "final", cache_control: { type: "ephemeral" } }),
-      ])
-    }),
-  )
-
   it.effect("auto policy preserves manual CacheHints on other parts", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(
@@ -310,30 +281,6 @@ describe("applyCachePolicy", () => {
     }),
   )
 
-  test("marks the final leaf inside a tool namespace", () => {
-    const request = LLM.request({
-      model: anthropicModel,
-      tools: [
-        {
-          type: "namespace",
-          name: "crm",
-          tools: [
-            { name: "lookup", description: "lookup", inputSchema: {} },
-            { name: "orders", description: "orders", inputSchema: {} },
-          ],
-        },
-      ],
-      cache: { tools: true },
-    })
-    const applied = applyCachePolicy(request)
-    const namespace = applied.tools[0]
-
-    expect(namespace?.type).toBe("namespace")
-    if (namespace?.type !== "namespace") throw new Error("Expected namespace")
-    expect(namespace.tools[0]).not.toHaveProperty("cache")
-    expect(namespace.tools[1]).toHaveProperty("cache", { type: "ephemeral" })
-  })
-
   it.effect("ttlSeconds in the policy flows through to wire markers", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/compaction-http.test.ts

@@ -1,97 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { LLM, LLMRequest, Message } from "../src/index.js"
-import { LLMClient } from "../src/route/client.js"
-import { OpenAI } from "../src/providers.js"
-import { testEffect } from "./lib/effect.js"
-import { runtimeLayer } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-
-testEffect(runtimeLayer(FetchHttpClient.layer)).live("compaction and a tool loop work end to end over HTTP", () =>
-  Effect.gen(function* () {
-    const checkpoint = { type: "compaction", id: "cmp_local", encrypted_content: "opaque-local-state" }
-    const calls: string[] = []
-    const server = yield* Effect.acquireRelease(
-      Effect.sync(() =>
-        Bun.serve({
-          hostname: "127.0.0.1",
-          port: 0,
-          async fetch(request) {
-            const path = new URL(request.url).pathname
-            calls.push(path)
-            const body = await request.json()
-            expect(request.headers.get("authorization")).toBe("Bearer fixture")
-            if (path === "/v1/responses/compact") {
-              expect(body.stream).toBeUndefined()
-              return Response.json({
-                object: "response.compaction",
-                output: [checkpoint],
-                usage: { input_tokens: 100, output_tokens: 10, total_tokens: 110 },
-              })
-            }
-            expect(body.input[0]).toEqual(checkpoint)
-            expect(body.stream).toBe(true)
-            if (calls.length === 2)
-              return new Response(
-                sseEvents(
-                  {
-                    type: "response.output_item.done",
-                    item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" },
-                  },
-                  { type: "response.completed", response: { id: "resp_1" } },
-                ),
-                { headers: { "content-type": "text/event-stream" } },
-              )
-            expect(body.input.at(-2)).toMatchObject({ type: "function_call", call_id: "call_1" })
-            expect(body.input.at(-1)).toEqual({ type: "function_call_output", call_id: "call_1", output: "42" })
-            const output = sseEvents(
-              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
-              { type: "response.output_text.delta", item_id: "msg_1", delta: "The answer is 42." },
-              {
-                type: "response.output_item.done",
-                item: { type: "message", id: "msg_1", content: [{ type: "output_text", text: "The answer is 42." }] },
-              },
-              { type: "response.completed", response: { id: "resp_2" } },
-            )
-            return new Response(
-              new ReadableStream({
-                start(controller) {
-                  controller.enqueue(new TextEncoder().encode(output.slice(0, 37)))
-                  controller.enqueue(new TextEncoder().encode(output.slice(37)))
-                  controller.close()
-                },
-              }),
-              { headers: { "content-type": "text/event-stream" } },
-            )
-          },
-        }),
-      ),
-      (server) => Effect.sync(() => server.stop(true)),
-    )
-    const model = OpenAI.configure({ apiKey: "fixture", baseURL: `http://127.0.0.1:${server.port}/v1` }).responses(
-      "fixture",
-    )
-    const request = LLM.request({
-      model,
-      prompt: "original",
-      tools: [{ name: "lookup", description: "Lookup a number", inputSchema: { type: "object", properties: {} } }],
-    })
-    const compacted = yield* LLMClient.compact(request)
-    const messages = [...compacted.replacement, Message.user("Look up the answer")]
-    const first = yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    expect(first.toolCalls).toHaveLength(1)
-    const call = first.toolCalls[0]!
-    const last = yield* LLMClient.generate(
-      LLMRequest.update(request, {
-        messages: [
-          ...messages,
-          first.message,
-          Message.tool({ id: call.id, name: call.name, result: "42", resultType: "text" }),
-        ],
-      }),
-    )
-    expect(last.text).toBe("The answer is 42.")
-    expect(calls).toEqual(["/v1/responses/compact", "/v1/responses", "/v1/responses"])
-  }),
-)

packages/ai/test/compaction.test.ts

@@ -1,101 +0,0 @@
-import { expect, test } from "bun:test"
-import { Effect, Schema } from "effect"
-import { CompactionPart, CompactionResponse, LLMEvent, LLMResponse, Message, ProviderID } from "../src/schema/index.js"
-import { LLM, LLMClient, LLMRequest, LanguageModel } from "../src/index.js"
-import { OpenAI, Anthropic } from "../src/providers.js"
-import { testEffect } from "./lib/effect.js"
-import { fixedResponse } from "./lib/http.js"
-
-test("runtime capability checks follow model and route updates", () => {
-  const supported = OpenAI.configure({ apiKey: "test" }).responses("fixture")
-  const unsupported = Anthropic.configure({ apiKey: "test" }).model("fixture")
-  const request = LLM.request({ model: supported, prompt: "hello" })
-  expect(LLMClient.canCompact(request)).toBe(true)
-  expect(LLMClient.canCompact(LLMRequest.update(request, { messages: [] }))).toBe(true)
-  expect(LLMClient.canCompact(LLMRequest.update(request, { model: unsupported }))).toBe(false)
-  expect(
-    LLMClient.canCompact(LLM.request({ model: LanguageModel.update(supported, { route: unsupported.route }) })),
-  ).toBe(false)
-  expect(LLMClient.canCompact(LLM.request({ model: LanguageModel.update(supported, { route: undefined }) }))).toBe(true)
-})
-
-test("explicit compaction serializes a replacement window without a messages alias", () => {
-  const response = new CompactionResponse({
-    replacement: [
-      Message.user("retained input"),
-      Message.assistant(CompactionPart.make({ provider: ProviderID.make("openai"), encrypted: "checkpoint" })),
-    ],
-  })
-  const codec = Schema.fromJsonString(CompactionResponse)
-  const decoded = Schema.decodeSync(codec)(Schema.encodeSync(codec)(response))
-  expect(decoded.replacement).toEqual(response.replacement)
-  expect("messages" in decoded).toBe(false)
-})
-
-test("compaction survives event assembly and message serialization without becoming text", () => {
-  const part = CompactionPart.make({
-    provider: ProviderID.make("openai"),
-    id: "cmp_1",
-    encrypted: "opaque",
-  })
-  const response = LLMResponse.fromEvents([
-    LLMEvent.textStart({ id: "before" }),
-    LLMEvent.textDelta({ id: "before", text: "Before" }),
-    LLMEvent.textEnd({ id: "before" }),
-    part,
-    LLMEvent.textStart({ id: "after" }),
-    LLMEvent.textDelta({ id: "after", text: "After" }),
-    LLMEvent.textEnd({ id: "after" }),
-    LLMEvent.finish({ reason: { normalized: "stop" } }),
-  ])!
-  expect(response.message.content.map((part) => part.type)).toEqual(["text", "compaction", "text"])
-  expect(response.text).toBe("BeforeAfter")
-  expect(response.reasoning).toBe("")
-  expect(response.events.filter(LLMEvent.is.compaction)).toEqual([part])
-  const codec = Schema.fromJsonString(Message)
-  expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(response.message))).toEqual(response.message)
-})
-
-test("compaction requires exactly one typed representation", () => {
-  const provider = ProviderID.make("anthropic")
-  expect(CompactionPart.make({ provider, text: null })).toEqual({ type: "compaction", provider, text: null })
-  const decode = Schema.decodeUnknownSync(CompactionPart)
-  expect(() => decode({ type: "compaction", provider })).toThrow()
-  expect(() => decode({ type: "compaction", provider, text: "summary", encrypted: "opaque" })).toThrow()
-})
-
-test("tagged content and event guards accept both checkpoint representations", () => {
-  for (const part of [
-    CompactionPart.make({ provider: ProviderID.make("openai"), encrypted: "opaque" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: "summary" }),
-    CompactionPart.make({ provider: ProviderID.make("anthropic"), text: null }),
-  ]) {
-    expect(LLMEvent.is.compaction(part)).toBe(true)
-    expect(LLMEvent.guards.compaction(part)).toBe(true)
-    const codec = Schema.fromJsonString(Message)
-    const message = Message.assistant(part)
-    expect(Schema.decodeSync(codec)(Schema.encodeSync(codec)(message))).toEqual(message)
-  }
-})
-
-testEffect(fixedResponse("")).effect(
-  "explicit compaction on a route without a compact endpoint fails with UnsupportedOperation",
-  () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model: Anthropic.configure({ apiKey: "test" }).model("fixture"),
-        prompt: "hello",
-      })
-      expect(LLMClient.canCompact(request)).toBe(false)
-      const error = yield* LLMClient.compact(
-        request as unknown as Parameters<typeof LLMClient.compact>[0],
-      ).pipe(Effect.flip)
-      expect(error.reason._tag).toBe("UnsupportedOperation")
-      expect(error.message).toContain("does not support explicit compaction")
-      if (error.reason._tag === "UnsupportedOperation") {
-        expect(error.reason.operation).toBe("compact")
-        expect(error.reason.provider).toBe("anthropic")
-        expect(error.reason.route).toBe("anthropic-messages")
-      }
-    }),
-)

packages/ai/test/compile.test.ts

@@ -1,16 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Ref, Schema } from "effect"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import {
-  LLM,
-  LLMRequest,
-  Message,
-  ToolCallPart,
-  ToolDefinition,
-  ToolNamespace,
-  mergeProviderOptions,
-} from "../src/index.js"
-import { AnthropicMessages, OpenAIChat, OpenAIResponses } from "../src/protocols.js"
+import { LLM, LLMRequest, Message, ToolCallPart, ToolDefinition, mergeProviderOptions } from "../src/index.js"
+import { AnthropicMessages, OpenAIChat } from "../src/protocols.js"
 import { Auth, LLMClient } from "../src/route.js"
 import { compileRequest } from "../src/route/client.js"
 import { it } from "./lib/effect.js"
@@ -114,58 +106,6 @@ describe("request option precedence", () => {
     }),
   )
 
-  it.effect("deduplicates tools within each namespace", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: OpenAIResponses.route.model({ id: "gpt-5.4" }),
-          tools: [
-            ToolDefinition.make({ name: "crm", description: "Top-level CRM tool", inputSchema: {} }),
-            ToolNamespace.make({
-              name: "crm",
-              description: "CRM tools",
-              tools: [
-                ToolDefinition.make({ name: "lookup", description: "old", inputSchema: {} }),
-                ToolDefinition.make({ name: "search", description: "search", inputSchema: {} }),
-                ToolDefinition.make({ name: "lookup", description: "new", inputSchema: {} }),
-              ],
-            }),
-            ToolNamespace.make({
-              name: "support",
-              description: "Support tools",
-              tools: [ToolDefinition.make({ name: "lookup", description: "support", inputSchema: {} })],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          name: "crm",
-          description: "Top-level CRM tool",
-          parameters: {},
-          strict: false,
-        },
-        {
-          type: "namespace",
-          name: "crm",
-          description: "CRM tools",
-          tools: [
-            { type: "function", name: "lookup", description: "new", parameters: {}, strict: false },
-            { type: "function", name: "search", description: "search", parameters: {}, strict: false },
-          ],
-        },
-        {
-          type: "namespace",
-          name: "support",
-          description: "Support tools",
-          tools: [{ type: "function", name: "lookup", description: "support", parameters: {}, strict: false }],
-        },
-      ])
-    }),
-  )
-
   it.effect("normalizes tool history before protocol lowering", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

packages/ai/test/llm.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { CacheHint, LLM, LLMResponse, ToolEntry, ToolNamespace } from "../src/index.js"
+import { CacheHint, LLM, LLMResponse } from "../src/index.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAIResponses from "../src/protocols/openai-responses.js"
 import {
@@ -18,52 +17,6 @@ const chatRoute = OpenAIChat.route
 const responsesRoute = OpenAIResponses.route
 
 describe("llm constructors", () => {
-  test("normalizes recursive tool namespaces", () => {
-    const request = LLM.request({
-      model: LanguageModel.make({ id: "fake-model", provider: "fake", route: responsesRoute }),
-      tools: [
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [
-            { name: "lookup", description: "Look up a customer", inputSchema: { type: "object" } },
-            {
-              type: "namespace",
-              name: "orders",
-              tools: [{ name: "list", description: "List orders", inputSchema: { type: "object" } }],
-            },
-          ],
-        },
-      ],
-    })
-
-    expect(request.tools[0]).toEqual({
-      type: "namespace",
-      name: "crm",
-      description: "Customer management",
-      tools: [
-        expect.objectContaining({ type: "tool", name: "lookup" }),
-        {
-          type: "namespace",
-          name: "orders",
-          description: undefined,
-          tools: [expect.objectContaining({ type: "tool", name: "list" })],
-        },
-      ],
-    })
-    expect(request.tools[0]).toEqual(
-      ToolNamespace.make({
-        name: "crm",
-        description: "Customer management",
-        tools: request.tools[0]!.type === "namespace" ? request.tools[0].tools : [],
-      }),
-    )
-    expect(Schema.decodeUnknownSync(ToolEntry)(Schema.encodeUnknownSync(ToolEntry)(request.tools[0]))).toEqual(
-      request.tools[0],
-    )
-  })
-
   test("builds canonical schema classes from ergonomic input", () => {
     const request = LLM.request({
       id: "req_1",

packages/ai/test/provider-options/compaction.types.ts

@@ -1,133 +0,0 @@
-import { Effect } from "effect"
-import {
-  CompactionPart,
-  LanguageModel,
-  LLM,
-  LLMClient,
-  LLMEvent,
-  LLMRequest,
-  Message,
-  ProviderID,
-} from "../../src/index.js"
-import { OpenAI, Azure, XAI, Anthropic, OpenAICompatibleResponses } from "../../src/providers.js"
-
-const openai = OpenAI.configure({
-  apiKey: "test",
-  providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-}).responses("gpt-5.3-codex")
-LLMClient.compact(LLM.request({ model: openai, prompt: "hello" }))
-
-for (const model of [
-  OpenAI.configure().responses("fixture"),
-  Azure.configure({ resourceName: "test" }).responses("fixture"),
-  XAI.configure().responses("fixture"),
-  OpenAI.model("fixture", {}),
-  Azure.responsesModel("fixture", { resourceName: "test" }),
-  XAI.model("fixture", {}),
-  openai.route.with({ headers: { "x-test": "test" } }).model({ id: "fixture" }),
-  LanguageModel.update(openai, { defaults: { generation: { maxTokens: 100 } } }),
-  LanguageModel.make(LanguageModel.input(openai)),
-]) {
-  LLMClient.compact(LLM.request({ model, prompt: "hello" }))
-}
-
-const unsupported = {
-  anthropic: LLM.request({ model: Anthropic.configure().model("fixture") }),
-  openaiChat: LLM.request({ model: OpenAI.configure().chat("fixture") }),
-  azureChat: LLM.request({ model: Azure.configure({ resourceName: "test" }).chat("fixture") }),
-  xaiChat: LLM.request({ model: XAI.configure().chat("fixture") }),
-  compatible: LLM.request({
-    model: OpenAICompatibleResponses.configure({ baseURL: "https://example.com" }).model("fixture"),
-  }),
-}
-// @ts-expect-error Anthropic has no standalone compact endpoint.
-LLMClient.compact(unsupported.anthropic)
-// @ts-expect-error Chat does not expose Responses compaction.
-LLMClient.compact(unsupported.openaiChat)
-// @ts-expect-error Azure Chat does not expose Responses compaction.
-LLMClient.compact(unsupported.azureChat)
-// @ts-expect-error xAI Chat does not expose Responses compaction.
-LLMClient.compact(unsupported.xaiChat)
-// @ts-expect-error Protocol compatibility does not guarantee endpoint support.
-LLMClient.compact(unsupported.compatible)
-LLMClient.Service.use((client) => {
-  // @ts-expect-error The service enforces the same capability as the convenience function.
-  return client.compact(unsupported.anthropic)
-})
-
-const request = LLM.request({ model: openai, prompt: "hello" })
-LLMClient.compact(LLMRequest.update(request, { messages: [Message.user("continue")] }))
-LLMClient.compact(new LLMRequest(LLMRequest.input(request)))
-const switched = LLMRequest.update(request, { model: Anthropic.configure().model("fixture") })
-// @ts-expect-error Switching models replaces, rather than inherits, the capability.
-LLMClient.compact(switched)
-LLMClient.compact(LLMRequest.update(switched, { model: openai }))
-LLMClient.compact(
-  // @ts-expect-error Replacing the route also replaces compaction capability.
-  LLM.request({ model: LanguageModel.update(openai, { route: Anthropic.configure().model("fixture").route }) }),
-)
-
-declare const dynamicModel: LanguageModel
-declare const dynamicPatch: Partial<LLMRequest.Input>
-const dynamicRequest = LLM.request({ model: dynamicModel, prompt: "hello" })
-// @ts-expect-error A dynamically selected model must be narrowed first.
-LLMClient.compact(dynamicRequest)
-if (LLMClient.canCompact(dynamicRequest)) LLMClient.compact(dynamicRequest)
-// @ts-expect-error An optional model override cannot retain the old capability statically.
-LLMClient.compact(LLMRequest.update(request, dynamicPatch))
-
-const checkpoint = CompactionPart.make({ provider: ProviderID.make("openai"), id: "cmp_1", encrypted: "opaque" })
-const provider = ProviderID.make("anthropic")
-CompactionPart.make({ provider, text: "summary" })
-CompactionPart.make({ provider, text: null })
-// @ts-expect-error A checkpoint must have a representation.
-CompactionPart.make({ provider })
-// @ts-expect-error Encrypted and summary representations are mutually exclusive.
-CompactionPart.make({ provider, encrypted: "opaque", text: "summary" })
-// @ts-expect-error A failed summary cannot also carry encrypted content.
-LLMEvent.compaction({ provider, encrypted: "opaque", text: null })
-// @ts-expect-error The canonical message type also enforces the invariant.
-Message.assistant({ type: "compaction", provider })
-if (checkpoint.encrypted !== undefined) {
-  checkpoint.encrypted satisfies string
-  checkpoint.text satisfies undefined
-}
-if (checkpoint.text !== undefined) {
-  checkpoint.text satisfies string | null
-  checkpoint.encrypted satisfies undefined
-}
-checkpoint.encrypted
-// @ts-expect-error Compaction parts do not contain a generic provider payload.
-checkpoint.value
-LLMClient.compact(LLM.request({ model: openai, prompt: "hello" })).pipe(
-  Effect.map((result) => {
-    result.replacement satisfies ReadonlyArray<Message>
-    // @ts-expect-error The replacement window is named explicitly; the old field is not an alias.
-    result.messages
-    // @ts-expect-error Compaction returns replacement history, not a synthetic assistant message.
-    result.message
-  }),
-)
-LLM.request({
-  model: openai,
-  providerOptions: {
-    // @ts-expect-error A token threshold is numeric.
-    contextManagement: [{ type: "compaction", compactThreshold: "100000" }],
-  },
-})
-const anthropic = Anthropic.configure().model("claude-opus-4-6")
-LLM.request({
-  model: anthropic,
-  providerOptions: {
-    contextManagement: {
-      edits: [{ type: "compact_20260112", pauseAfterCompaction: true, instructions: "Summarize without using tools" }],
-    },
-  },
-})
-LLM.request({
-  model: anthropic,
-  providerOptions: {
-    // @ts-expect-error A pause setting is boolean.
-    contextManagement: { edits: [{ type: "compact_20260112", pauseAfterCompaction: "yes" }] },
-  },
-})

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

@@ -1,170 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { Anthropic, GoogleVertexMessages } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-for (const fixture of [
-  {
-    name: "empty iterations fall back to top-level usage",
-    usage: { input_tokens: 2, output_tokens: 3, cache_read_input_tokens: null, iterations: [] },
-    expected: { inputTokens: 2, outputTokens: 3, totalTokens: 5, contextTokens: undefined },
-  },
-  {
-    name: "compaction-only usage has no post-compaction context size",
-    usage: {
-      input_tokens: 0,
-      output_tokens: 0,
-      iterations: [{ type: "compaction", input_tokens: 7, cache_read_input_tokens: 3, output_tokens: 2 }],
-    },
-    expected: { inputTokens: 10, outputTokens: 2, totalTokens: 12, contextTokens: undefined },
-  },
-  {
-    name: "partially reported iterations preserve known totals",
-    usage: {
-      iterations: [
-        { type: "compaction", input_tokens: 7, cache_creation_input_tokens: 2 },
-        { type: "message", output_tokens: 3 },
-      ],
-    },
-    expected: { inputTokens: 9, outputTokens: 3, totalTokens: 12, contextTokens: undefined },
-  },
-  {
-    name: "missing counters remain unknown rather than zero",
-    usage: { iterations: [{ type: "message" }] },
-    expected: { inputTokens: undefined, outputTokens: undefined, totalTokens: undefined, contextTokens: undefined },
-  },
-]) {
-  testEffect(
-    fixedResponse(
-      sseEvents(
-        { type: "message_start", message: { usage: fixture.usage } },
-        { type: "message_delta", delta: { stop_reason: "end_turn" } },
-        { type: "message_stop" },
-      ),
-    ),
-  ).effect(fixture.name, () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.generate(
-        LLM.request({
-          model: Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-          prompt: "hello",
-        }),
-      )
-      expect(result.usage).toMatchObject(fixture.expected)
-    }),
-  )
-}
-
-for (const model of [
-  Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-  GoogleVertexMessages.configure({ accessToken: "test", project: "test" }).model("claude-opus-4-6"),
-]) {
-  for (const summary of ["Summary of the conversation", null]) {
-    const block = { type: "compaction", content: summary }
-    testEffect(
-      dynamicResponse(({ request, text, respond }) =>
-        Effect.sync(() => {
-          const body = JSON.parse(text)
-          expect(request.headers["anthropic-beta"]).toBe("existing-beta,compact-2026-01-12")
-          if (body.messages.length === 1) {
-            expect(body.context_management.edits).toEqual([
-              {
-                type: "compact_20260112",
-                trigger: { type: "input_tokens", value: 50000 },
-                pause_after_compaction: true,
-              },
-            ])
-          }
-          if (body.messages.length > 1) {
-            expect(body.messages[1].content).toEqual([block])
-            expect(body.context_management).toBeUndefined()
-          }
-          return respond(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 50000, output_tokens: 0 } } },
-              { type: "content_block_start", index: 0, content_block: { type: "compaction", content: null } },
-              { type: "content_block_delta", index: 0, delta: { type: "compaction_delta", content: summary } },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "compaction" },
-                usage: {
-                  input_tokens: 1000,
-                  output_tokens: 5,
-                  iterations: [
-                    { type: "compaction", input_tokens: 50000, output_tokens: 1000, cache_read_input_tokens: 10 },
-                    { type: "message", input_tokens: 1000, output_tokens: 5 },
-                  ],
-                },
-              },
-              { type: "message_stop" },
-            ),
-            { headers: { "content-type": "text/event-stream" } },
-          )
-        }),
-      ),
-    ).effect(
-      `${model.provider} replays ${summary === null ? "failed" : "successful"} compaction with billing and context usage`,
-      () =>
-        Effect.gen(function* () {
-          const request = LLM.request({
-            model,
-            prompt: "hello",
-            http: { headers: { "anthropic-beta": "existing-beta" } },
-            providerOptions: {
-              contextManagement: {
-                edits: [
-                  {
-                    type: "compact_20260112",
-                    trigger: { type: "input_tokens", value: 50000 },
-                    pauseAfterCompaction: true,
-                  },
-                ],
-              },
-            },
-          })
-          const first = yield* LLMClient.generate(request)
-          expect(first.finishReason.raw).toBe("compaction")
-          expect(first.message.content).toEqual([{ type: "compaction", provider: model.provider, text: summary }])
-          expect(first.text).toBe("")
-          expect(first.usage?.inputTokens).toBe(51010)
-          expect(first.usage?.outputTokens).toBe(1005)
-          expect(first.usage?.totalTokens).toBe(52015)
-          expect(first.usage?.contextTokens).toBe(1000)
-          const codec = Schema.fromJsonString(Message)
-          const message = Schema.decodeSync(codec)(Schema.encodeSync(codec)(first.message))
-          yield* LLMClient.generate(
-            LLMRequest.update(request, {
-              providerOptions: {},
-              messages: [...request.messages, message, Message.user("continue")],
-            }),
-          )
-        }),
-    )
-  }
-}
-
-for (const events of [
-  [{ type: "content_block_start", index: 0, content_block: { type: "compaction", content: 42 } }],
-  [{ type: "content_block_delta", index: 0, delta: { type: "compaction_delta", content: "no start" } }],
-  [
-    { type: "content_block_start", index: 0, content_block: { type: "compaction", content: null } },
-    { type: "message_stop" },
-  ],
-]) {
-  testEffect(fixedResponse(sseEvents(...events))).effect(
-    `rejects malformed compaction lifecycle: ${JSON.stringify(events)}`,
-    () =>
-      Effect.gen(function* () {
-        const error = yield* LLMClient.generate(
-          LLM.request({ model: Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"), prompt: "hello" }),
-        ).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-        expect(error.reason.http?.status).toBe(200)
-      }),
-  )
-}

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

@@ -713,10 +713,9 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("ignores tool deltas without an open tool block", () =>
+  it.effect("ignores late tool deltas after contentBlockStop", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(
-        ["contentBlockDelta", { contentBlockIndex: 5, delta: { toolUse: { input: "{}" } } }],
         [
           "contentBlockStart",
           {
@@ -746,6 +745,27 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
+  it.effect("rejects tool deltas without contentBlockStart", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(
+            eventStreamBody(
+              ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: "{}" } } }],
+              ["messageStop", { stopReason: "tool_use" }],
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error).toMatchObject({
+        reason: { _tag: "InvalidProviderOutput" },
+        message: "Bedrock Converse tool delta is missing its tool call",
+      })
+    }),
+  )
+
   it.effect("recovers incomplete tool input at finalization", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(

packages/ai/test/provider/compaction-websocket.test.ts

@@ -1,50 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient, WebSocketTransport } from "../../src/route.js"
-import { OpenAI } from "../../src/providers.js"
-import { testEffect } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-
-testEffect(fixedResponse("unexpected HTTP fallback")).effect(
-  "WebSocket responses preserve compaction options and replay state",
-  () =>
-    Effect.gen(function* () {
-      const checkpoint = { type: "compaction", id: "cmp_ws", encrypted_content: "opaque" }
-      const sent: unknown[] = []
-      const webSocket = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            sendText: (message) =>
-              Effect.sync(() => {
-                const body = JSON.parse(message)
-                expect(body.context_management).toEqual([{ type: "compaction", compact_threshold: 100000 }])
-                expect(body.stream).toBeUndefined()
-                if (sent.length) expect(body.input[1]).toEqual(checkpoint)
-                sent.push(body)
-              }),
-            messages: Stream.fromIterable(
-              [
-                { type: "response.created", response: { id: "resp_ws" } },
-                { type: "response.output_item.done", item: checkpoint },
-                { type: "response.completed", response: { id: "resp_ws", output: [checkpoint] } },
-              ].map((event) => JSON.stringify(event)),
-            ),
-            close: Effect.void,
-          }),
-      })
-      const request = LLM.request({
-        model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-        prompt: "hello",
-        providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-      })
-      const first = yield* LLMClient.generate(request, { webSocket })
-      expect(first.message.content).toHaveLength(1)
-      expect(first.message.content[0]?.type).toBe("compaction")
-      yield* LLMClient.generate(
-        LLMRequest.update(request, { messages: [...request.messages, first.message, Message.user("continue")] }),
-        { webSocket },
-      )
-      expect(sent).toHaveLength(2)
-    }),
-)

packages/ai/test/provider/compaction.recorded.test.ts

@@ -1,91 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { OpenAI, XAI, Anthropic } from "../../src/providers.js"
-import { recordedTests } from "../recorded-test.js"
-
-const history = [
-  Message.user("Remember the project codename COPPER-ORBIT-42."),
-  Message.assistant(
-    "The project codename is COPPER-ORBIT-42. " + "We reviewed the implementation and tests. ".repeat(1000),
-  ),
-]
-
-for (const provider of [
-  {
-    id: "openai",
-    key: "OPENAI_API_KEY",
-    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" }).responses("gpt-5.3-codex"),
-  },
-  {
-    id: "xai",
-    key: "XAI_API_KEY",
-    model: XAI.configure({ apiKey: process.env.XAI_API_KEY ?? "fixture" }).responses("grok-4.6"),
-  },
-]) {
-  recordedTests({ prefix: `${provider.id}-compaction`, provider: provider.id, requires: [provider.key] }).effect(
-    "compacts and continues with the provider checkpoint",
-    () =>
-      Effect.gen(function* () {
-        const request = LLM.request({ model: provider.model, messages: history, generation: { maxTokens: 1024 } })
-        const compacted = yield* LLMClient.compact(request)
-        const result = yield* LLMClient.generate(
-          LLMRequest.update(request, {
-            messages: [
-              ...compacted.replacement,
-              Message.user("What is the project codename? Reply only with the codename."),
-            ],
-          }),
-        )
-        expect(result.text).toContain("COPPER-ORBIT-42")
-      }),
-    120000,
-  )
-}
-
-recordedTests({
-  prefix: "anthropic-compaction",
-  provider: "anthropic",
-  requires: ["ANTHROPIC_API_KEY"],
-  options: { redact: { allowRequestHeaders: ["anthropic-version", "anthropic-beta"] } },
-}).effect(
-  "automatically compacts and continues after a pause",
-  () =>
-    Effect.gen(function* () {
-      const model = Anthropic.configure({ apiKey: process.env.ANTHROPIC_API_KEY ?? "fixture" }).model(
-        "claude-sonnet-4-6",
-      )
-      const request = LLM.request({
-        model,
-        messages: [
-          Message.user(
-            "Remember the project codename COPPER-ORBIT-42. " +
-              "The implementation and tests were reviewed. ".repeat(10000),
-          ),
-        ],
-        generation: { maxTokens: 4096 },
-        providerOptions: {
-          contextManagement: {
-            edits: [
-              { type: "compact_20260112", trigger: { type: "input_tokens", value: 50000 }, pauseAfterCompaction: true },
-            ],
-          },
-        },
-      })
-      const first = yield* LLMClient.generate(request)
-      expect(first.finishReason.raw).toBe("compaction")
-      expect(first.message.content.some((part) => part.type === "compaction")).toBe(true)
-      const result = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [
-            ...request.messages,
-            first.message,
-            Message.user("What is the project codename? Reply only with the codename."),
-          ],
-        }),
-      )
-      expect(result.text).toContain("COPPER-ORBIT-42")
-    }),
-  120000,
-)

packages/ai/test/provider/compaction.test.ts

@@ -1,139 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message } from "../../src/index.js"
-import { LLMClient } from "../../src/route/client.js"
-import { OpenAI, Azure, XAI } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
-const response = sseEvents(
-  { type: "response.output_item.done", item: checkpoint },
-  {
-    type: "response.completed",
-    response: { id: "resp_1", output: [checkpoint], usage: { input_tokens: 10, output_tokens: 2, total_tokens: 12 } },
-  },
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("deployment"),
-]) {
-  testEffect(
-    dynamicResponse(({ text, respond }) =>
-      Effect.sync(() => {
-        const body = JSON.parse(text)
-        expect(body.context_management).toEqual([{ type: "compaction", compact_threshold: 100000 }])
-        expect(body.store).toBe(false)
-        if (body.input.length > 1) expect(body.input[1]).toEqual(checkpoint)
-        return respond(response, { headers: { "content-type": "text/event-stream" } })
-      }),
-    ),
-  ).effect(`${model.provider} compaction survives generation, serialization, and a second request`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model,
-        prompt: "hello",
-        providerOptions: { contextManagement: [{ type: "compaction", compactThreshold: 100000 }] },
-      })
-      const first = yield* LLMClient.generate(request)
-      expect(first.message.content).toHaveLength(1)
-      expect(first.message.content[0]?.type).toBe("compaction")
-      expect(first.text).toBe("")
-      const codec = Schema.fromJsonString(Message)
-      const message = Schema.decodeSync(codec)(Schema.encodeSync(codec)(first.message))
-      yield* LLMClient.generate(
-        LLMRequest.update(request, { messages: [...request.messages, message, Message.user("continue")] }),
-      )
-      const rejected = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          model: XAI.configure({ apiKey: "test" }).responses("grok-4.6"),
-          providerOptions: {},
-          messages: [message],
-        }),
-      ).pipe(Effect.flip)
-      expect(rejected.reason._tag).toBe("InvalidRequest")
-    }),
-  )
-}
-
-testEffect(fixedResponse(sseEvents({ type: "response.completed", response: { output: [checkpoint] } }))).effect(
-  "recovers compaction from the terminal output when item completion is absent",
-  () =>
-    Effect.gen(function* () {
-      const result = yield* LLMClient.generate(
-        LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-      )
-      expect(result.message.content).toHaveLength(1)
-      expect(result.message.content[0]?.type).toBe("compaction")
-    }),
-)
-
-testEffect(
-  fixedResponse(sseEvents({ type: "response.output_item.done", item: { type: "compaction", id: "cmp_bad" } })),
-).effect("rejects incomplete compaction payloads without publishing a checkpoint", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.generate(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidProviderOutput")
-    expect(error.reason.body).toContain("cmp_bad")
-  }),
-)
-
-const textItem = {
-  type: "message",
-  id: "msg_after",
-  role: "assistant",
-  content: [{ type: "output_text", text: "After checkpoint" }],
-}
-
-for (const completed of [false, true]) {
-  testEffect(
-    fixedResponse(
-      sseEvents(
-        { type: "response.output_item.added", output_index: 0, item: { type: "compaction", id: checkpoint.id } },
-        ...(completed ? [{ type: "response.output_item.done", output_index: 0, item: checkpoint }] : []),
-        { type: "response.output_item.added", output_index: 1, item: textItem },
-        { type: "response.output_text.delta", output_index: 1, item_id: textItem.id, delta: "After checkpoint" },
-        { type: "response.output_item.done", output_index: 1, item: textItem },
-        { type: "response.completed", response: { id: "resp_1", output: [checkpoint, textItem] } },
-      ),
-    ),
-  ).effect(completed ? "keeps streamed checkpoints before later text" : "rejects order-unsafe terminal recovery", () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" })
-      if (completed) {
-        const response = yield* LLMClient.generate(request)
-        expect(response.message.content.map((part) => part.type)).toEqual(["compaction", "text"])
-        return
-      }
-      const error = yield* LLMClient.generate(request).pipe(Effect.flip)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("Cannot recover a compaction checkpoint")
-      expect(error.reason.body).toContain("response.completed")
-      expect(error.reason.http?.status).toBe(200)
-    }),
-  )
-}
-
-testEffect(
-  fixedResponse(
-    sseEvents({
-      type: "response.completed",
-      response: { output: [{ type: "compaction", encrypted_content: "opaque" }] },
-    }),
-  ),
-).effect("mints an id for terminal checkpoints that omit one", () =>
-  Effect.gen(function* () {
-    const response = yield* LLMClient.generate(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" }),
-    )
-    const part = response.message.content[0]
-    expect(part?.type).toBe("compaction")
-    if (part?.type !== "compaction") return
-    expect(part.id).toMatch(/^cmp_[0-9a-f]{32}$/)
-    expect(part.encrypted).toBe("opaque")
-  }),
-)

packages/ai/test/provider/conversation-lowering.test.ts

@@ -1,30 +0,0 @@
-import { expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, Message } from "../../src/index.js"
-import { OpenAI } from "../../src/providers.js"
-import { OpenResponses } from "../../src/protocols/open-responses.js"
-import { it } from "../lib/effect.js"
-
-it.effect("conversation lowering excludes generation settings and tool definitions", () =>
-  Effect.gen(function* () {
-    const body = yield* OpenResponses.lowerConversation(
-      LLM.request({
-        model: OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-        system: "Keep the context",
-        messages: [Message.user("hello"), Message.assistant("hi")],
-        generation: { maxTokens: 100, temperature: 0.5 },
-        providerOptions: { store: false },
-        tools: [{ name: "unsupported", description: "Generation only", inputSchema: {}, native: { unsupported: {} } }],
-      }),
-      { id: "open-responses", name: "Open Responses" },
-    )
-    expect(body).toEqual({
-      model: "fixture",
-      instructions: "Keep the context",
-      input: [
-        { role: "user", content: [{ type: "input_text", text: "hello" }] },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "hi" }] },
-      ],
-    })
-  }),
-)

packages/ai/test/provider/explicit-compaction.test.ts

@@ -1,461 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, LLMRequest, Message, ToolDefinition } from "../../src/index.js"
-import { LLMClient, Route } from "../../src/route/client.js"
-import { Auth } from "../../src/route/auth.js"
-import { Endpoint } from "../../src/route/endpoint.js"
-import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
-import { OpenAI, Azure, XAI, Anthropic, OpenAICompatibleResponses } from "../../src/providers/index.js"
-import { testEffect } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-const checkpoint = { type: "compaction", id: "cmp_1", encrypted_content: "opaque" }
-const retained = {
-  type: "message",
-  role: "user",
-  id: "msg_1",
-  status: "completed",
-  content: [{ type: "input_text", text: "retained" }],
-}
-const output = [retained, checkpoint]
-
-testEffect(
-  dynamicResponse(({ request, text, respond }) =>
-    Effect.sync(() => {
-      expect(request.headers["x-deployment"]).toBe("fixture")
-      expect(request.headers["x-override"]).toBe("request")
-      expect(request.headers["x-default"]).toBe("configured")
-      expect(request.headers.authorization).toBe("Bearer test")
-      expect(new URL(request.url).searchParams.get("api-version")).toBe("fixture")
-      expect(new URL(request.url).searchParams.get("trace")).toBe("request")
-      if (new URL(request.url).pathname.endsWith("/compact")) {
-        expect(JSON.parse(text)).toEqual({
-          model: "overlaid",
-          input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }],
-          instructions: "request instructions",
-          previous_response_id: "resp_previous",
-        })
-        return respond(JSON.stringify({ object: "response.compaction", output }))
-      }
-      return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }))
-    }),
-  ),
-).effect("generation and compaction share deployment headers, defaults, auth, query, and middleware", () =>
-  Effect.gen(function* () {
-    const headers: string[] = []
-    const middleware: string[] = []
-    const route = Route.make({
-      id: "compaction-headers",
-      provider: "openai",
-      protocol: OpenAIResponses.protocol,
-      compact: OpenAIResponses.route.compact,
-      transport: OpenAIResponses.httpTransport,
-      endpoint: Endpoint.path(({ body }) => `/${body.model}/responses`, {
-        baseURL: "https://example.com",
-        query: { "api-version": "fixture" },
-      }),
-      auth: Auth.bearer("test"),
-      headers: ({ request }) => {
-        expect(request.providerOptions?.store).toBe(false)
-        headers.push(String(request.model.id))
-        return { "x-deployment": "fixture", "x-override": "route" }
-      },
-      defaults: {
-        headers: { "x-default": "configured", "x-override": "configured" },
-        providerOptions: { store: false },
-        http: { body: { instructions: "default instructions" } },
-      },
-    })
-    const request = LLM.request({
-      model: route.model({ id: "fixture" }),
-      prompt: "hello",
-      system: "system instructions",
-      http: {
-        headers: { "x-override": "request" },
-        query: { trace: "request" },
-        body: {
-          model: "overlaid",
-          instructions: "request instructions",
-          previous_response_id: "resp_previous",
-          store: false,
-          stream: true,
-        },
-      },
-    })
-    const options: Parameters<typeof LLMClient.compact>[1] = {
-      http: (request, next) => {
-        middleware.push(new URL(request.url).pathname)
-        return next(request)
-      },
-    }
-    yield* LLMClient.generate(request, options)
-    yield* LLMClient.compact(request, options)
-    expect(headers).toEqual(["fixture", "fixture"])
-    expect(middleware).toEqual(["/fixture/responses", "/fixture/responses/compact"])
-  }),
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("fixture"),
-  XAI.configure({ apiKey: "test" }).responses("fixture"),
-]) {
-  const item = {
-    type: model.provider === "xai" ? "x_search_call" : "computer_call",
-    id: "hosted_1",
-    status: "completed",
-  }
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        expect(new URL(request.url).pathname).toEndWith("/responses/compact")
-        expect(JSON.parse(text)).toEqual({ model: "fixture", input: [item], instructions: "Keep the context" })
-        return respond(JSON.stringify({ object: "response.compaction", output: [checkpoint] }))
-      }),
-    ),
-  ).effect(`${model.provider} compacts provider-specific history without lowering generation settings`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model,
-        system: "Keep the context",
-        messages: [
-          Message.assistant({
-            type: "tool-result",
-            id: item.id,
-            name: item.type,
-            result: { type: "json", value: item },
-            providerExecuted: true,
-            providerMetadata: { [model.route.providerMetadataKey ?? model.provider]: { itemId: item.id } },
-          }),
-        ],
-      })
-      for (const [candidate, tag] of [
-        [
-          LLMRequest.update(request, {
-            tools: [
-              ToolDefinition.make({
-                name: "unsupported",
-                description: "Generation only",
-                inputSchema: {},
-                native: { unsupported: {} },
-              }),
-            ],
-          }),
-          "InvalidRequest",
-        ],
-        [
-          LLMRequest.update(request, { providerOptions: { contextManagement: "invalid-generation-option" } }),
-          model.provider === "xai" ? "UnsupportedOperation" : "InvalidRequest",
-        ],
-      ] as const) {
-        const error = yield* LLMClient.generate(candidate).pipe(Effect.flip)
-        expect(error.reason._tag).toBe(tag)
-        const response = yield* LLMClient.compact(candidate)
-        expect(response.replacement[0]?.content[0]?.type).toBe("compaction")
-      }
-    }),
-  )
-}
-
-const retainedItems = [
-  retained,
-  {
-    type: "message",
-    id: "msg_assistant",
-    role: "assistant",
-    status: "completed",
-    phase: "commentary",
-    content: [
-      { type: "output_text", text: "First" },
-      { type: "output_text", text: "Second" },
-    ],
-  },
-  {
-    type: "reasoning",
-    id: "rs_1",
-    summary: [
-      { type: "summary_text", text: "Thinking" },
-      { type: "summary_text", text: "More thinking" },
-    ],
-    encrypted_content: "reasoning-state",
-  },
-  { type: "reasoning", id: "rs_2", summary: [], encrypted_content: "hidden-reasoning" },
-  {
-    type: "message",
-    id: "msg_media",
-    role: "user",
-    content: [
-      { type: "input_image", image_url: "https://example.com/image.png" },
-      { type: "input_file", filename: "report.pdf", file_data: "data:application/pdf;base64,cGRm", detail: "high" },
-      { type: "input_file", filename: "other.pdf", file_url: "https://example.com/report.pdf", detail: "low" },
-    ],
-  },
-  checkpoint,
-]
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-  ...[undefined, "custom"].map((providerMetadataKey) =>
-    Route.make({
-      id: providerMetadataKey ?? "default-metadata",
-      provider: "openai",
-      providerMetadataKey,
-      protocol: OpenAIResponses.protocol,
-      compact: OpenAIResponses.route.compact,
-      endpoint: OpenAIResponses.route.endpoint,
-      transport: OpenAIResponses.httpTransport,
-    }).model({ id: "fixture" }),
-  ),
-]) {
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        if (new URL(request.url).pathname.endsWith("/compact"))
-          return respond(JSON.stringify({ object: "response.compaction", output: retainedItems }))
-        expect(JSON.parse(text).input).toEqual(retainedItems)
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }), {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }),
-    ),
-  ).effect(`${model.route.id} retains messages, reasoning, and media through typed conversation parts`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({
-        model,
-        prompt: "hello",
-      })
-      const compacted = yield* LLMClient.compact(request)
-      expect(compacted.replacement.map((message) => message.role)).toEqual([
-        "user",
-        "assistant",
-        "assistant",
-        "assistant",
-        "user",
-        "assistant",
-      ])
-      expect(compacted.replacement[1]?.content).toEqual([
-        { type: "text", text: "First" },
-        { type: "text", text: "Second" },
-      ])
-      expect(compacted.replacement[2]?.content.map((part) => part.type)).toEqual(["reasoning", "reasoning"])
-      expect(compacted.replacement[4]?.content.map((part) => part.type)).toEqual(["media", "media", "media"])
-      const codec = Schema.fromJsonString(Schema.Array(Message))
-      const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.replacement))
-      yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    }),
-  )
-}
-
-for (const overlay of [undefined, { service_tier: "priority", prompt_cache_key: "overridden" }]) {
-  testEffect(
-    dynamicResponse(({ text, respond }) =>
-      Effect.sync(() => {
-        expect(JSON.parse(text)).toEqual({
-          model: "fixture",
-          input: [{ role: "user", content: [{ type: "input_text", text: "hello" }] }],
-          service_tier: overlay?.service_tier ?? "flex",
-          prompt_cache_key: overlay?.prompt_cache_key ?? "affinity",
-          prompt_cache_retention: "24h",
-          prompt_cache_options: { mode: "explicit", ttl: "30m" },
-        })
-        return respond(JSON.stringify({ object: "response.compaction", output: [checkpoint] }))
-      }),
-    ),
-  ).effect(`compact preserves supported request controls${overlay ? " with HTTP overrides" : ""}`, () =>
-    LLMClient.compact(
-      LLM.request({
-        model: OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-        prompt: "hello",
-        promptCacheKey: "affinity",
-        providerOptions: { serviceTier: "flex" },
-        generation: { maxTokens: 100 },
-        http: {
-          body: {
-            stream: true,
-            store: false,
-            prompt_cache_retention: "24h",
-            prompt_cache_options: { mode: "explicit", ttl: "30m" },
-            ...overlay,
-          },
-        },
-      }),
-    ),
-  )
-}
-
-for (const item of [
-  { type: "unknown_provider_item", data: "do not hide in a compaction part" },
-  {
-    type: "message",
-    role: "user",
-    content: [{ type: "input_image", image_url: "https://example.com/image.png", detail: 42 }],
-  },
-  { type: "message", role: "user", content: [] },
-  {
-    type: "message",
-    role: "assistant",
-    content: [{ type: "input_image", image_url: "https://example.com/image.png" }],
-  },
-  { type: "message", role: "user", content: [{ type: "input_file", filename: "missing.pdf" }] },
-  {
-    type: "message",
-    role: "user",
-    content: [{ type: "input_file", filename: "bad.pdf", file_url: "https://example.com/report.pdf", detail: 42 }],
-  },
-  {
-    type: "message",
-    role: "user",
-    content: [
-      {
-        type: "input_file",
-        filename: "both.pdf",
-        file_url: "https://example.com/report.pdf",
-        file_data: "data:application/pdf;base64,cGRm",
-      },
-    ],
-  },
-]) {
-  testEffect(fixedResponse(JSON.stringify({ object: "response.compaction", output: [item, checkpoint] }))).effect(
-    `rejects unsupported compact output: ${JSON.stringify(item)}`,
-    () =>
-      Effect.gen(function* () {
-        const error = yield* LLMClient.compact(
-          LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-        ).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-        expect(error.reason.body).toContain(JSON.stringify(item))
-        expect(error.reason.http?.status).toBe(200)
-      }),
-  )
-}
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("fixture"),
-  XAI.configure({ apiKey: "test" }).responses("fixture"),
-]) {
-  const images = [undefined, "low", "high", "auto"].map((detail) => ({
-    type: "input_image",
-    image_url: "https://example.com/image.png",
-    ...(detail === undefined ? {} : { detail }),
-  }))
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        if (new URL(request.url).pathname.endsWith("/compact"))
-          return respond(
-            JSON.stringify({
-              object: "response.compaction",
-              output: [{ type: "message", role: "user", content: images }, checkpoint],
-            }),
-          )
-        expect(JSON.parse(text).input[0].content).toEqual(images)
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1" } }))
-      }),
-    ),
-  ).effect(`${model.provider} preserves retained image detail through serialization and replay`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model, prompt: "hello" })
-      const compacted = yield* LLMClient.compact(request)
-      const codec = Schema.fromJsonString(Schema.Array(Message))
-      const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.replacement))
-      yield* LLMClient.generate(LLMRequest.update(request, { messages }))
-    }),
-  )
-}
-
-testEffect(fixedResponse("must not execute")).effect("xAI rejects automatic compaction options", () =>
-  Effect.gen(function* () {
-    const request = LLMRequest.update(
-      LLM.request({ model: XAI.configure({ apiKey: "test" }).responses("grok-4.6"), prompt: "hello" }),
-      { providerOptions: { contextManagement: [{ type: "compaction" }] } },
-    )
-    const error = yield* LLMClient.generate(request).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("UnsupportedOperation")
-    expect(error.message).toContain("LLMClient.compact")
-    if (error.reason._tag === "UnsupportedOperation") expect(error.reason.operation).toBe("in-band-compaction")
-  }),
-)
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("deployment"),
-  XAI.configure({ apiKey: "test" }).responses("grok-4.6"),
-]) {
-  testEffect(
-    dynamicResponse(({ request, text, respond }) =>
-      Effect.sync(() => {
-        const body = JSON.parse(text)
-        expect(request.method).toBe("POST")
-        expect(request.headers[model.provider === "azure" ? "api-key" : "authorization"]).toBe(
-          model.provider === "azure" ? "test" : "Bearer test",
-        )
-        if (new URL(request.url).pathname.endsWith("/responses/compact")) {
-          expect(body).toEqual({
-            model: model.id,
-            input: [{ role: "user", content: [{ type: "input_text", text: "original" }] }],
-            instructions: "system",
-          })
-          return respond(
-            JSON.stringify({
-              object: "response.compaction",
-              output,
-              usage: { input_tokens: 1000, output_tokens: 10, total_tokens: 1010 },
-            }),
-            { headers: { "content-type": "application/json" } },
-          )
-        }
-        expect(new URL(request.url).pathname.endsWith("/responses")).toBe(true)
-        expect(body.input).toEqual([...output, { role: "user", content: [{ type: "input_text", text: "continue" }] }])
-        return respond(sseEvents({ type: "response.completed", response: { id: "resp_1", output: [] } }), {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }),
-    ),
-  ).effect(`${model.provider} explicitly compacts and replays the entire canonical window`, () =>
-    Effect.gen(function* () {
-      const request = LLM.request({ model, prompt: "original", system: "system", http: { body: { store: false } } })
-      const compacted = yield* LLMClient.compact(request)
-      expect(compacted.usage?.totalTokens).toBe(1010)
-      expect(compacted.replacement.map((message) => message.role)).toEqual(["user", "assistant"])
-      expect(compacted.replacement[0]?.content).toEqual([{ type: "text", text: "retained" }])
-      expect(compacted.replacement[1]?.content).toEqual([
-        { type: "compaction", provider: model.provider, id: "cmp_1", encrypted: "opaque" },
-      ])
-      const codec = Schema.fromJsonString(Schema.Array(Message))
-      const messages = Schema.decodeSync(codec)(Schema.encodeSync(codec)(compacted.replacement))
-      yield* LLMClient.generate(LLMRequest.update(request, { messages: [...messages, Message.user("continue")] }))
-    }),
-  )
-}
-
-for (const model of [
-  Anthropic.configure({ apiKey: "test" }).model("claude-opus-4-6"),
-  OpenAICompatibleResponses.configure({ apiKey: "test", baseURL: "https://compatible.example/v1" }).model("model"),
-]) {
-  testEffect(fixedResponse("must not execute")).effect(
-    `${model.route.id} does not inherit an unsupported compact endpoint`,
-    () =>
-      Effect.gen(function* () {
-        // @ts-expect-error Untyped callers must still receive the runtime capability error.
-        const error = yield* LLMClient.compact(LLM.request({ model, prompt: "hello" })).pipe(Effect.flip)
-        expect(error.reason._tag).toBe("UnsupportedOperation")
-        expect(error.message).toContain("does not support explicit compaction")
-        if (error.reason._tag === "UnsupportedOperation") expect(error.reason.operation).toBe("compact")
-      }),
-  )
-}
-
-testEffect(
-  fixedResponse(JSON.stringify({ object: "response.compaction", output: [retained], debug: "original payload" })),
-).effect("invalid explicit compaction preserves the original response and HTTP context", () =>
-  Effect.gen(function* () {
-    const error = yield* LLMClient.compact(
-      LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("gpt-5.3-codex"), prompt: "hello" }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidProviderOutput")
-    expect(error.reason.body).toContain("original payload")
-    expect(error.reason.http?.status).toBe(200)
-  }),
-)

packages/ai/test/provider/image-detail.test.ts

@@ -1,60 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { LLM, Message } from "../../src/index.js"
-import { OpenAI, Azure, XAI } from "../../src/providers.js"
-import { compileRequest } from "../../src/route/client.js"
-import { it } from "../lib/effect.js"
-
-for (const model of [
-  OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-  Azure.configure({ apiKey: "test", resourceName: "test" }).responses("fixture"),
-  XAI.configure({ apiKey: "test" }).responses("fixture"),
-]) {
-  it.effect(`${model.provider} preserves image detail through message serialization and lowering`, () =>
-    Effect.gen(function* () {
-      const details = [undefined, "low", "high", "auto"]
-      const message = Message.user(
-        details.map((detail) => ({
-          type: "media",
-          mediaType: "image/png",
-          data: "https://example.com/image.png",
-          providerMetadata:
-            detail === undefined ? undefined : { [model.route.providerMetadataKey ?? model.provider]: { detail } },
-        })),
-      )
-      const codec = Schema.fromJsonString(Message)
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [Schema.decodeSync(codec)(Schema.encodeSync(codec)(message))],
-        }),
-      )
-      expect(prepared.body.input[0].content).toEqual(
-        details.map((detail) => ({
-          type: "input_image",
-          image_url: "https://example.com/image.png",
-          detail,
-        })),
-      )
-    }),
-  )
-}
-
-it.effect("rejects malformed image detail instead of silently discarding it", () =>
-  Effect.gen(function* () {
-    const error = yield* compileRequest(
-      LLM.request({
-        model: OpenAI.configure({ apiKey: "test" }).responses("fixture"),
-        messages: [
-          Message.user({
-            type: "media",
-            mediaType: "image/png",
-            data: "https://example.com/image.png",
-            providerMetadata: { openai: { detail: 42 } },
-          }),
-        ],
-      }),
-    ).pipe(Effect.flip)
-    expect(error.reason._tag).toBe("InvalidRequest")
-  }),
-)

packages/ai/test/provider/open-responses-finals.test.ts

@@ -82,6 +82,32 @@ describe("Open Responses completed item text", () => {
       expect(response.events.filter(LLMEvent.is.textStart)).toEqual([])
     }),
   )
+
+  it.effect("assembles a done-only message once across replayed item events", () =>
+    Effect.gen(function* () {
+      const item = {
+        type: "message",
+        id: "msg_1",
+        content: [{ type: "output_text", text: "Recovered" }],
+      }
+      const response = yield* generate(
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Ignored after resume" },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.output_item.done", item },
+        completed,
+      )
+      expect(response.text).toBe("Recovered")
+      expect(response.message.content).toEqual([
+        {
+          type: "text",
+          text: "Recovered",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1" } },
+        },
+      ])
+      expect(response.events.filter(LLMEvent.is.textEnd)).toHaveLength(1)
+    }),
+  )
 })
 
 describe("Open Responses completed item reasoning", () => {

packages/ai/test/provider/open-responses-lifecycle.test.ts

@@ -71,7 +71,7 @@ function expectLifecycle(events: ReadonlyArray<LLMEvent>, completed: boolean) {
 }
 
 describe("Open Responses basic-item lifecycles", () => {
-  it.effect("closes implicit summary boundaries", () =>
+  it.effect("closes implicit summary boundaries and ignores late events for completed reasoning", () =>
     Effect.gen(function* () {
       const item = { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" }
       const events = yield* collect(
@@ -90,6 +90,12 @@ describe("Open Responses basic-item lifecycles", () => {
           delta: "Third",
         },
         { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 3 },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 3, delta: "late" },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 2, text: "late final" },
+        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 3 },
         completed,
       )
 
@@ -123,7 +129,7 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  it.effect("preserves done-only reasoning text and encryption", () =>
+  it.effect("preserves done-only reasoning text and encryption without replaying late events", () =>
     Effect.gen(function* () {
       const item = {
         type: "reasoning",
@@ -133,6 +139,11 @@ describe("Open Responses basic-item lifecycles", () => {
       }
       const events = yield* collect(
         { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "late" },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "late final" },
         completed,
         // Route termination must also prevent events after response completion.
         { type: "response.output_item.added", item: { type: "reasoning", id: "rs_after" } },
@@ -206,7 +217,7 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  it.effect("preserves non-empty done-only message content", () =>
+  it.effect("preserves non-empty done-only message content without replaying duplicates", () =>
     Effect.gen(function* () {
       const text = {
         type: "message",
@@ -219,11 +230,17 @@ describe("Open Responses basic-item lifecycles", () => {
         content: [{ type: "refusal", refusal: "Done-only refusal." }],
       }
       const events = yield* collect(
+        { type: "response.output_item.done", item: text },
         { type: "response.output_item.done", item: text },
         {
           type: "response.output_item.done",
           item: { type: "message", id: "msg_empty", content: [{ type: "output_text", text: "" }] },
         },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_empty", content: [{ type: "output_text", text: "Late" }] },
+        },
+        { type: "response.output_item.done", item: refusal },
         { type: "response.output_item.done", item: refusal },
         completed,
       )
@@ -255,127 +272,126 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
-  // Captured from Bedrock Mantle (openai.gpt-oss-120b): the terminal function_call
-  // items rename `id` to `item_id` and carry a stray `output_index`.
-  it.effect("recovers a terminal function_call id from its output slot", () =>
-    Effect.gen(function* () {
-      const terminal = {
-        type: "function_call",
-        item_id: "fc_828bee50dee1d029",
-        call_id: "call_bc1eb4b42e70ee53",
-        name: "get_weather",
-        arguments: '{\n  "city": "Paris"\n}',
-        output_index: 1,
-        status: "completed",
-      }
-      const events = yield* collect(
-        {
-          type: "response.output_item.added",
-          output_index: 0,
-          item: { type: "reasoning", id: "msg_879a68b589198b4c" },
-        },
-        { type: "response.output_item.done", output_index: 0, item: { type: "reasoning", id: "msg_879a68b589198b4c" } },
-        {
-          type: "response.output_item.added",
-          output_index: 1,
-          item: {
-            type: "function_call",
-            id: "fc_828bee50dee1d029",
-            call_id: "call_bc1eb4b42e70ee53",
-            name: "get_weather",
-            arguments: "",
-            status: "in_progress",
-          },
-        },
-        {
-          type: "response.function_call_arguments.delta",
-          output_index: 1,
-          item_id: "fc_828bee50dee1d029",
-          delta: '{\n  "city": "Paris"\n}',
-        },
-        {
-          type: "response.function_call_arguments.done",
-          output_index: 1,
-          item_id: "fc_828bee50dee1d029",
-          arguments: '{\n  "city": "Paris"\n}',
-        },
-        { type: "response.output_item.done", output_index: 1, item: terminal },
-        {
-          type: "response.completed",
-          response: { id: "resp_1", output: [{ type: "reasoning", id: "msg_879a68b589198b4c" }, terminal] },
-        },
-      )
-      const providerMetadata = { "openai-compatible": { itemId: "fc_828bee50dee1d029" } }
-      expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
-        { type: "tool-input-start", id: "call_bc1eb4b42e70ee53", name: "get_weather", providerMetadata },
-        {
-          type: "tool-input-delta",
-          id: "call_bc1eb4b42e70ee53",
-          name: "get_weather",
-          text: '{\n  "city": "Paris"\n}',
-          input: { city: "Paris" },
-        },
-        { type: "tool-input-end", id: "call_bc1eb4b42e70ee53", name: "get_weather", providerMetadata },
-        {
-          type: "tool-call",
-          id: "call_bc1eb4b42e70ee53",
-          name: "get_weather",
-          input: { city: "Paris" },
-          providerMetadata,
-        },
-      ])
-    }),
-  )
-  it.effect("mints an id for a done-only tool that never had one", () =>
+  it.effect("treats a repeated message lifecycle as replay", () =>
     Effect.gen(function* () {
       const events = yield* collect(
-        {
-          type: "response.output_item.done",
-          output_index: 0,
-          item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
-        },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Second" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
         completed,
       )
-      const call = events.find(LLMEvent.is.toolCall)
-      expect(call).toMatchObject({ id: "call_1", name: "lookup", input: { query: "weather" } })
-      expect(call?.providerMetadata?.["openai-compatible"]).toMatchObject({
-        itemId: expect.stringMatching(/^fc_[0-9a-f]{32}$/),
-      })
+      expect(events.filter(LLMEvent.is.textEnd)).toEqual([
+        {
+          type: "text-end",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+      ])
+      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["First"])
     }),
   )
 
-  it.effect("opens and closes a done-only tool", () =>
+  it.effect("ignores a stale done-only message while another message is active", () =>
     Effect.gen(function* () {
-      const item = {
-        type: "function_call",
-        id: "fc_1",
-        call_id: "call_1",
-        name: "lookup",
-        arguments: '{"query":"weather"}',
-      }
-      const events = yield* collect({ type: "response.output_item.done", item }, completed)
-      const providerMetadata = { "openai-compatible": { itemId: "fc_1" } }
-      expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
-        { type: "tool-input-start", id: "call_1", name: "lookup", namespace: undefined, providerMetadata },
-        { type: "tool-input-end", id: "call_1", name: "lookup", namespace: undefined, providerMetadata },
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Draft" },
         {
-          type: "tool-call",
-          id: "call_1",
-          name: "lookup",
-          namespace: undefined,
-          input: { query: "weather" },
-          providerMetadata,
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_2", content: [{ type: "output_text", text: "Recovered" }] },
         },
-      ])
-      expect(events.filter(LLMEvent.is.finish)).toEqual([
         {
-          type: "finish",
-          reason: { normalized: "tool-calls", raw: undefined },
-          providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_1", content: [{ type: "output_text", text: "Final" }] },
+        },
+        {
+          type: "response.output_item.done",
+          item: { type: "message", id: "msg_2", content: [{ type: "output_text", text: "Late" }] },
+        },
+        completed,
+      )
+      expect(events.filter((event) => event.type.startsWith("text-"))).toEqual([
+        {
+          type: "text-start",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+        { type: "text-delta", id: "msg_1", text: "Draft" },
+        {
+          type: "text-end",
+          id: "msg_1",
+          text: "Final",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
         },
       ])
     }),
   )
+  ;[undefined, "fc_1"].forEach((id) => {
+    it.effect(`opens and closes a done-only tool ${id === undefined ? "without" : "with"} an item id`, () =>
+      Effect.gen(function* () {
+        const item = {
+          type: "function_call",
+          ...(id === undefined ? {} : { id }),
+          call_id: "call_1",
+          name: "lookup",
+          arguments: '{"query":"weather"}',
+        }
+        const events = yield* collect(
+          { type: "response.output_item.done", item },
+          { type: "response.output_item.done", item: { ...item, id: "fc_1" } },
+          { type: "response.output_item.added", item },
+          completed,
+        )
+        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
+        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
+          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
+        ])
+        expect(events.filter(LLMEvent.is.finish)).toEqual([
+          {
+            type: "finish",
+            reason: { normalized: "tool-calls", raw: undefined },
+            providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
+          },
+        ])
+      }),
+    )
+
+    it.effect(`deduplicates a pending call whose item id is ${id === undefined ? "introduced" : "omitted"} later`, () =>
+      Effect.gen(function* () {
+        const item = { type: "function_call", call_id: "call_1", name: "lookup" }
+        const first = { ...item, ...(id === undefined ? {} : { id }) }
+        const duplicate = { ...item, ...(id === undefined ? { id: "fc_1" } : {}) }
+        const events = yield* collect(
+          { type: "response.output_item.added", item: first },
+          { type: "response.function_call_arguments.delta", item_id: id ?? "call_1", delta: '{"query":"weather"}' },
+          { type: "response.output_item.added", item: duplicate },
+          { type: "response.output_item.done", item: duplicate },
+          { type: "response.output_item.done", item: first },
+          { type: "response.output_item.added", item: duplicate },
+          completed,
+        )
+        // Identity metadata comes from the first admission, not the duplicate.
+        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
+        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
+          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
+          {
+            type: "tool-input-delta",
+            id: "call_1",
+            name: "lookup",
+            text: '{"query":"weather"}',
+            input: { query: "weather" },
+          },
+          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
+        ])
+      }),
+    )
+  })
 
   it.effect("recovers pending calls without reconciling terminal reasoning", () =>
     Effect.gen(function* () {
@@ -420,6 +436,21 @@ describe("Open Responses basic-item lifecycles", () => {
     }),
   )
 
+  it.effect("preserves call identity and pending order when an item id is reused", () =>
+    Effect.gen(function* () {
+      const first = { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" }
+      const events = yield* collect(
+        { type: "response.output_item.added", item: first },
+        { type: "response.output_item.added", item: { ...first, id: "fc_2", call_id: "call_2" } },
+        { type: "response.output_item.done", item: first },
+        { type: "response.output_item.added", item: { ...first, call_id: "call_3" } },
+        { type: "response.output_item.done", item: first },
+        completed,
+      )
+      expect(events.filter(LLMEvent.is.toolCall).map((event) => event.id)).toEqual(["call_1", "call_2", "call_3"])
+    }),
+  )
+
   it.effect("keeps text and reasoning identities separate even with empty item ids", () =>
     Effect.gen(function* () {
       const events = yield* collect(
@@ -469,15 +500,14 @@ describe("Open Responses basic-item lifecycles", () => {
         { type: "response.output_text.delta", item_id: "msg_1", delta: "Answer" },
         {
           type: "response.output_item.added",
-          item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" },
+          item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "{}" },
         },
         completed,
       )
       // Generic terminal closure does not repeat the message's phase metadata.
-      const providerMetadata = { "openai-compatible": { itemId: "fc_1" } }
       expect(events.slice(4, -2)).toEqual([
-        { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
-        { type: "tool-call", id: "call_1", name: "lookup", input: {}, providerMetadata },
+        { type: "tool-input-end", id: "call_1", name: "lookup" },
+        { type: "tool-call", id: "call_1", name: "lookup", input: {} },
         { type: "text-end", id: "msg_1" },
       ])
     }),

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

@@ -171,66 +171,6 @@ describe("Open Responses-compatible route", () => {
     }),
   )
 
-  it.effect("flattens tool namespaces", () =>
-    Effect.gen(function* () {
-      const model = configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model(
-        "example-model",
-      )
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "acme",
-              tools: [
-                {
-                  type: "namespace",
-                  name: "billing",
-                  tools: [ToolDefinition.make({ name: "lookup", description: "Lookup billing", inputSchema: {} })],
-                },
-                ToolDefinition.make({ name: "users", description: "Lookup users", inputSchema: {} }),
-              ],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "function",
-          name: "acme_billing_lookup",
-          description: "Lookup billing",
-          parameters: {},
-          strict: false,
-        },
-        { type: "function", name: "acme_users", description: "Lookup users", parameters: {}, strict: false },
-      ])
-    }),
-  )
-
-  it.effect("flattens tool namespaces in history", () =>
-    Effect.gen(function* () {
-      const model = configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model(
-        "example-model",
-      )
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant({ type: "tool-call", id: "call_1", name: "lookup", namespace: "crm", input: {} }),
-            Message.tool({ id: "call_1", name: "lookup", namespace: "crm", result: "done", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.input).toEqual([
-        { type: "function_call", call_id: "call_1", name: "crm_lookup", namespace: undefined, arguments: "{}" },
-        { type: "function_call_output", call_id: "call_1", output: "done" },
-      ])
-    }),
-  )
-
   it.effect("lowers canonical parallel tool control", () =>
     Effect.gen(function* () {
       const model = configure({
@@ -646,21 +586,23 @@ describe("Open Responses-compatible route", () => {
       Effect.gen(function* () {
         yield* Effect.forEach(["response.output_item.added", "response.output_item.done"], (type) =>
           Effect.forEach(fixtures, (fixture) =>
-            Effect.forEach([null, 0, false, {}, []], (id) =>
-              Effect.gen(function* () {
-                const error = yield* LLMClient.generate(request).pipe(
-                  Effect.provide(
-                    fixedResponse(
-                      sseEvents(
-                        { type, item: { ...fixture.item, id } },
-                        { type: "response.completed", response: { id: "resp_1" } },
+            Effect.forEach(
+              fixture.item.type === "message" ? [undefined, null, 0, false, {}, []] : [null, 0, false, {}, []],
+              (id) =>
+                Effect.gen(function* () {
+                  const error = yield* LLMClient.generate(request).pipe(
+                    Effect.provide(
+                      fixedResponse(
+                        sseEvents(
+                          { type, item: { ...fixture.item, id } },
+                          { type: "response.completed", response: { id: "resp_1" } },
+                        ),
                       ),
                     ),
-                  ),
-                  Effect.flip,
-                )
-                expect(error.reason._tag).toBe("InvalidProviderOutput")
-              }),
+                    Effect.flip,
+                  )
+                  expect(error.reason._tag).toBe("InvalidProviderOutput")
+                }),
             ),
           ),
         )
@@ -668,6 +610,43 @@ describe("Open Responses-compatible route", () => {
     )
   })
 
+  it.effect("streams function calls without optional item ids through the shared baseline", () =>
+    Effect.gen(function* () {
+      const model = configure({
+        apiKey: "test-key",
+        baseURL: "https://responses.example.test/v1",
+        provider: "example",
+      }).model("example-model")
+      const item = { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" }
+      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Look it up." })).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { type: "response.output_item.added", output_index: 1, item },
+              {
+                type: "response.function_call_arguments.delta",
+                output_index: 1,
+                item_id: "opaque_item",
+                delta: '{"query":"shared"}',
+              },
+              {
+                type: "response.output_item.done",
+                output_index: 1,
+                item: { ...item, arguments: '{"query":"complete"}' },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
+        expect.objectContaining({ id: "call_1", name: "lookup", input: { query: "complete" } }),
+      ])
+      expect(response.events.find(LLMEvent.is.toolCall)?.providerMetadata).toBeUndefined()
+    }),
+  )
+
   it.effect("finalizes pending function calls from completed response output", () =>
     Effect.gen(function* () {
       const model = configure({

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

@@ -12,7 +12,6 @@ import {
   LanguageModel,
   ToolCallPart,
   ToolDefinition,
-  ToolNamespace,
   ToolResultPart,
   TransportError,
   Usage,
@@ -144,94 +143,6 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("lowers tool namespaces without flattening leaf names", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          prompt: "Find a customer and their orders.",
-          tools: [
-            ToolNamespace.make({
-              name: "crm",
-              description: "Customer management",
-              tools: [
-                ToolDefinition.make({ name: "lookup", description: "Look up a customer", inputSchema: {} }),
-                ToolDefinition.make({ name: "orders", description: "List customer orders", inputSchema: {} }),
-              ],
-            }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [
-            { type: "function", name: "lookup", description: "Look up a customer", parameters: {}, strict: false },
-            { type: "function", name: "orders", description: "List customer orders", parameters: {}, strict: false },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("flattens nested levels within a native tool namespace", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "crm",
-              description: "Customer management",
-              tools: [
-                {
-                  type: "namespace",
-                  name: "orders",
-                  description: "Order management",
-                  tools: [ToolDefinition.make({ name: "list", description: "List orders", inputSchema: {} })],
-                },
-              ],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        {
-          type: "namespace",
-          name: "crm",
-          description: "Customer management",
-          tools: [{ type: "function", name: "orders_list", description: "List orders", parameters: {}, strict: false }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("defaults tool namespace descriptions", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          tools: [
-            {
-              type: "namespace",
-              name: "crm",
-              tools: [ToolDefinition.make({ name: "lookup", description: "Look up a customer", inputSchema: {} })],
-            },
-          ],
-        }),
-      )
-
-      expect(prepared.body.tools).toEqual([
-        expect.objectContaining({ type: "namespace", name: "crm", description: "Tools in the crm namespace." }),
-      ])
-    }),
-  )
-
   it.effect("rejects invalid hosted image generation options locally", () =>
     Effect.gen(function* () {
       const error = yield* compileRequest(
@@ -558,7 +469,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("continues a streamed tool call with only the new tool output", () =>
+  it.effect("continues an item-id-less tool call with only the new tool output", () =>
     Effect.gen(function* () {
       const firstRequest = {
         type: "response.create",
@@ -574,7 +485,6 @@ describe("OpenAI Responses route", () => {
           type: "response.output_item.done",
           item: {
             type: "function_call",
-            id: "fc_1",
             status: "completed",
             call_id: "call_1",
             name: "weather",
@@ -2219,31 +2129,30 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("preserves tool namespaces through streaming and history replay", () =>
+  it.effect("routes item-id-less function arguments by output index and prefers item completion", () =>
     Effect.gen(function* () {
-      const item = {
-        type: "function_call",
-        id: "fc_1",
-        call_id: "call_1",
-        namespace: "crm",
-        name: "lookup",
-        arguments: "",
-      }
+      const item = { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" }
       const response = yield* LLMClient.generate(request).pipe(
         Effect.provide(
           fixedResponse(
             sseEvents(
-              { type: "response.output_item.added", output_index: 0, item },
+              { type: "response.output_item.added", output_index: 2, item },
               {
                 type: "response.function_call_arguments.delta",
-                output_index: 0,
-                item_id: "fc_1",
-                delta: '{"id":"123"}',
+                output_index: 2,
+                item_id: "opaque_delta",
+                delta: '{"query":"streamed"}',
+              },
+              {
+                type: "response.function_call_arguments.done",
+                output_index: 2,
+                item_id: "opaque_done",
+                arguments: '{"query":"arguments-done"}',
               },
               {
                 type: "response.output_item.done",
-                output_index: 0,
-                item: { ...item, arguments: '{"id":"123"}' },
+                output_index: 2,
+                item: { ...item, arguments: '{"query":"output-item-done"}' },
               },
               { type: "response.completed", response: { id: "resp_1" } },
             ),
@@ -2251,39 +2160,16 @@ describe("OpenAI Responses route", () => {
         ),
       )
 
-      const toolEvents = response.events.filter((event) => event.type.startsWith("tool-"))
-      expect(toolEvents).toEqual([
-        expect.objectContaining({ type: "tool-input-start", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-input-delta", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-input-end", name: "lookup", namespace: "crm" }),
-        expect.objectContaining({ type: "tool-call", name: "lookup", namespace: "crm", input: { id: "123" } }),
+      expect(response.events.filter((event) => event.type === "tool-input-delta")).toMatchObject([
+        { id: "call_1", text: '{"query":"streamed"}' },
       ])
-      expect(response.message.content).toEqual([
-        expect.objectContaining({ type: "tool-call", name: "lookup", namespace: "crm", input: { id: "123" } }),
-      ])
-
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            response.message,
-            Message.tool({ id: "call_1", name: "lookup", namespace: "crm", result: { customer: "Ada" } }),
-          ],
-        }),
-      )
-      expect(prepared.body.input).toEqual([
-        {
-          type: "function_call",
-          id: "fc_1",
-          call_id: "call_1",
-          namespace: "crm",
-          name: "lookup",
-          arguments: '{"id":"123"}',
-        },
-        { type: "function_call_output", call_id: "call_1", output: '{"customer":"Ada"}' },
+      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
+        expect.objectContaining({ id: "call_1", name: "lookup", input: { query: "output-item-done" } }),
       ])
+      expect(response.events.find(LLMEvent.is.toolCall)?.providerMetadata).toBeUndefined()
     }),
   )
+
   it.effect("routes reasoning summary events by output index", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(
@@ -2503,7 +2389,7 @@ describe("OpenAI Responses route", () => {
                 {
                   type: "response.output_item.added",
                   output_index: 0,
-                  item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
+                  item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" },
                 },
                 event,
                 { type: "response.completed", response: { id: "resp_1" } },
@@ -3004,7 +2890,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("ignores duplicate item start events", () =>
+  it.effect("ignores duplicate item boundary events", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(
         Effect.provide(
@@ -3015,6 +2901,7 @@ describe("OpenAI Responses route", () => {
               { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
               { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "Think" },
               { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
+              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
               {
                 type: "response.output_item.added",
                 item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
@@ -3034,6 +2921,25 @@ describe("OpenAI Responses route", () => {
                   arguments: '{"query":"weather"}',
                 },
               },
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "function_call",
+                  id: "fc_1",
+                  call_id: "call_1",
+                  name: "lookup",
+                  arguments: '{"query":"weather"}',
+                },
+              },
+              // Duplicates that drop the item id still resolve the same call.
+              {
+                type: "response.output_item.done",
+                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
+              },
+              {
+                type: "response.output_item.added",
+                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" },
+              },
               { type: "response.completed", response: { id: "resp_1" } },
             ),
           ),
@@ -3887,6 +3793,43 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("finalizes and replays a completed function call without an optional item id", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              {
+                type: "response.output_item.done",
+                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
+        expect.objectContaining({ id: "call_1", name: "lookup", input: { query: "weather" } }),
+      ])
+      expect(response.events.find(LLMEvent.is.toolCall)?.providerMetadata).toBeUndefined()
+
+      const prepared = yield* compileRequest(
+        LLM.request({
+          model,
+          messages: [
+            response.message,
+            Message.tool({ id: "call_1", name: "lookup", resultType: "json", result: { forecast: "sunny" } }),
+          ],
+        }),
+      )
+      expect(prepared.body.input).toEqual([
+        { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
+        { type: "function_call_output", call_id: "call_1", output: '{"forecast":"sunny"}' },
+      ])
+    }),
+  )
+
   it.effect("emits only missing function arguments from the arguments done event", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -4074,7 +4017,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("uses completed response output when output item completion is missing", () =>
+  it.effect("uses completed response output when item completion and its terminal item id are missing", () =>
     Effect.gen(function* () {
       const body = sseEvents(
         {
@@ -4089,7 +4032,6 @@ describe("OpenAI Responses route", () => {
             output: [
               {
                 type: "function_call",
-                id: "fc_item_1",
                 call_id: "call_1",
                 name: "lookup",
                 arguments: '{"query":"weather"}',
@@ -4111,6 +4053,37 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("reconciles an item-id-less pending function call from completed response output", () =>
+    Effect.gen(function* () {
+      const item = { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" }
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { type: "response.output_item.added", output_index: 0, item },
+              {
+                type: "response.function_call_arguments.delta",
+                output_index: 0,
+                item_id: "opaque_delta",
+                delta: '{"query":"partial',
+              },
+              {
+                type: "response.completed",
+                response: { id: "resp_1", output: [{ ...item, arguments: '{"query":"complete"}' }] },
+              },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
+        expect.objectContaining({ id: "call_1", name: "lookup", input: { query: "complete" } }),
+      ])
+      expect(response.events.find(LLMEvent.is.toolCall)?.providerMetadata).toBeUndefined()
+      expect(response.events.filter(LLMEvent.is.toolInputEnd)).toHaveLength(1)
+    }),
+  )
+
   it.effect("lets completed response output override arguments done", () =>
     Effect.gen(function* () {
       const body = sseEvents(

packages/ai/test/schema.test.ts

@@ -24,7 +24,6 @@ import {
   ToolResultValue,
   TransportError,
   UnknownProviderError,
-  UnsupportedOperationError,
   Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
@@ -277,12 +276,6 @@ test("AI errors serialize diagnostics only on their typed reason", () => {
 test("AI error reasons are tagged Errors with required messages", () => {
   const reasons = [
     new InvalidRequestError({ message: "Invalid request" }),
-    new UnsupportedOperationError({
-      message: "Unsupported operation",
-      operation: "compact",
-      provider: model.provider,
-      route: "fake-route",
-    }),
     new NoRouteError({
       message: "No route",
       route: RouteID.make("missing"),
@@ -300,7 +293,6 @@ test("AI error reasons are tagged Errors with required messages", () => {
   ]
   expect(reasons.map((reason) => reason._tag)).toEqual([
     "InvalidRequest",
-    "UnsupportedOperation",
     "NoRoute",
     "Authentication",
     "RateLimit",

packages/ai/test/testing.test.ts

@@ -1,18 +1,5 @@
 import { describe, expect } from "bun:test"
-import {
-  AIError,
-  CompactionPart,
-  CompactionResponse,
-  LanguageModel,
-  LLM,
-  LLMClient,
-  LLMEvent,
-  LLMRequest,
-  Message,
-  ProviderID,
-  RateLimitError,
-} from "../src/index.js"
-import { OpenAI } from "../src/providers.js"
+import { AIError, LanguageModel, LLM, LLMClient, LLMEvent, LLMRequest, RateLimitError } from "../src/index.js"
 import { OpenAIChat } from "../src/protocols/openai-chat.js"
 import { TestLLM } from "../src/testing.js"
 import { Effect, Fiber, Latch, Stream } from "effect"
@@ -79,54 +66,6 @@ describe("TestLLM legacy client", () => {
 })
 
 describe("TestLLM first-class client", () => {
-  it.effect("rejects response fixtures for the wrong operation", () =>
-    Effect.gen(function* () {
-      const client = yield* TestLLM.Test
-      const request = LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" })
-      yield* client.push(TestLLM.stop(), new CompactionResponse({ replacement: [] }))
-      expect(yield* client.compact(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(
-        "TestLLM compaction requires a CompactionResponse",
-      )
-      expect(yield* client.generate(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(
-        "TestLLM generation requires an event response",
-      )
-    }),
-  )
-
-  it.effect("scripts replacement windows with the same lazy recording, gates, and fallback controls", () =>
-    Effect.gen(function* () {
-      const client = yield* TestLLM.Test
-      const request = LLM.request({ model: OpenAI.configure({ apiKey: "test" }).responses("fixture"), prompt: "hello" })
-      const compacted = new CompactionResponse({
-        replacement: [
-          Message.user("retained input"),
-          Message.assistant(CompactionPart.make({ provider: ProviderID.make("openai"), encrypted: "checkpoint" })),
-          Message.user("retained tail"),
-        ],
-      })
-      yield* client.push(compacted, TestLLM.text("continued", "answer"))
-      const operation = LLMClient.compact(request)
-      expect(yield* client.requests()).toEqual([])
-      const gate = yield* client.gate()
-      const fiber = yield* operation.pipe(Effect.forkChild({ startImmediately: true }))
-      yield* gate.started
-      yield* client.wait(1)
-      expect(fiber.pollUnsafe()).toBeUndefined()
-      yield* gate.release
-      expect(yield* Fiber.join(fiber)).toBe(compacted)
-      const next = LLMRequest.update(request, { messages: compacted.replacement })
-      expect((yield* LLMClient.generate(next)).text).toBe("continued")
-      yield* client.serve((observed) => {
-        expect(observed).toBe(next)
-        return compacted
-      })
-      expect(yield* LLMClient.compact(next)).toBe(compacted)
-      yield* client.always(compacted)
-      expect(yield* LLMClient.compact(next)).toBe(compacted)
-      expect(yield* client.requests()).toEqual([request, next, next, next])
-    }),
-  )
-
   it.effect("provides the same object under normal and test tags with snapshot observations", () =>
     Effect.gen(function* () {
       const llm = yield* TestLLM.Test

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

@@ -15,7 +15,13 @@ describe("tool history normalization", () => {
       Message.assistant(toolCall("trailing")),
     ])
 
-    expect(normalized.map((message) => message.role)).toEqual(["assistant", "tool", "tool", "user", "assistant"])
+    expect(normalized.map((message) => message.role)).toEqual([
+      "assistant",
+      "tool",
+      "tool",
+      "user",
+      "assistant",
+    ])
     expect(normalized[1]?.content[0]).toMatchObject({ type: "tool-result", id: "first", name: "first" })
     expect(normalized[2]?.content).toEqual([
       { type: "tool-result", id: "second", name: "second", result: { type: "error", value: "Tool result missing" } },
@@ -68,13 +74,4 @@ describe("tool history normalization", () => {
 
     expect(normalizeToolHistory([orphan, hosted])).toEqual([orphan, hosted])
   })
-
-  test("uses a matching call as the complete tool identity", () => {
-    const normalized = normalizeToolHistory([
-      Message.assistant(ToolCallPart.make({ id: "call_1", name: "lookup", input: {} })),
-      Message.tool(ToolResultPart.make({ id: "call_1", name: "wrong", namespace: "stale", result: "done" })),
-    ])
-
-    expect(normalized[1]?.content[0]).toMatchObject({ name: "lookup", namespace: undefined })
-  })
 })

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

@@ -7,7 +7,6 @@ import {
   LLMEvent,
   LLMRequest,
   LLMResponse,
-  ToolCallPart,
   ToolChoice,
   ToolOutput,
   toDefinitions,
@@ -37,27 +36,6 @@ const baseRequest = LLM.request({
 })
 const weatherFailureCause = new Error("weather lookup denied")
 
-test("dispatches namespaced calls by qualified identity", async () => {
-  let context: ToolExecuteContext | undefined
-  const lookup = Tool.make({
-    description: "Look up a customer.",
-    parameters: Schema.Struct({}),
-    success: Schema.String,
-    execute: (_, value) => {
-      context = value
-      return Effect.succeed("customer")
-    },
-  })
-  const call = ToolCallPart.make({ id: "call_1", namespace: "crm", name: "lookup", input: {} })
-  const result = await Effect.runPromise(
-    ToolRuntime.dispatch({ "crm.lookup": lookup, lookup: schema_only_weather }, call),
-  )
-
-  expect(result.result).toEqual({ type: "text", value: "customer" })
-  expect(context).toEqual({ id: "call_1", namespace: "crm", name: "lookup" })
-  expect(result.events).toEqual([expect.objectContaining({ type: "tool-result", namespace: "crm", name: "lookup" })])
-})
-
 const get_weather = Tool.make({
   description: "Get current weather for a city.",
   parameters: Schema.Struct({ city: Schema.String }),

packages/app/component-tests/open-in-border.spec.ts

@@ -1,18 +0,0 @@
-import { expect, story } from "../../storybook/playwright/story"
-
-for (const theme of ["light", "dark"]) {
-  story(`keeps the Open in border visible without hovering (${theme})`, async ({ mount, page }, testInfo) => {
-    const component = await mount("ui-split-button--open-in", { globals: { theme } })
-    const control = component.locator('[data-component="split-button-v2"]')
-    await page.mouse.move(0, 0)
-    await expect(control).toBeVisible()
-    await expect(control).not.toHaveCSS("box-shadow", "none")
-    const border = await control.evaluate((element) => getComputedStyle(element).boxShadow)
-
-    await component.getByRole("button", { name: "Open options" }).hover()
-    await expect(control).toHaveCSS("box-shadow", border)
-    await page.mouse.move(0, 0)
-    await expect(control).toHaveCSS("box-shadow", border)
-    await control.screenshot({ path: testInfo.outputPath(`open-in-${theme}.png`) })
-  })
-}

packages/app/e2e/performance/command-palette-benchmark.spec.ts

@@ -1,47 +0,0 @@
-import { benchmark, expect } from "./benchmark"
-import { openCommandPalette } from "../utils/command-palette"
-
-benchmark.use({
-  viewport: { width: 1440, height: 900 },
-  serviceWorkers: "block",
-  traceScope: "interaction",
-  trace: "off",
-  video: "off",
-})
-
-for (const home of [false, true]) {
-  benchmark(`command lookup from ${home ? "home" : "session"}`, async ({ page, report }) => {
-    const { dialog, input } = await openCommandPalette(page, home)
-    const title = home ? "Open settings" : "Copy Session ID"
-    const query = home ? "open settings" : "copy session"
-    // Measure input-to-selected-result in the renderer, without assertion polling overhead.
-    await input.evaluate((element, title) => {
-      element.addEventListener(
-        "input",
-        () => {
-          performance.mark("palette-input")
-          const observer = new MutationObserver(() => {
-            if (document.querySelectorAll('[role="dialog"] [role="option"]').length !== 1) return
-            const selected = document.querySelector('[role="dialog"] [role="option"][aria-selected="true"]')
-            if (!selected?.textContent?.includes(title)) return
-            performance.measure("palette-result", "palette-input")
-            observer.disconnect()
-          })
-          observer.observe(document, { subtree: true, childList: true, attributes: true, characterData: true })
-        },
-        { once: true, capture: true },
-      )
-    }, title)
-    await input.fill(query)
-    await expect(dialog.getByRole("option")).toHaveCount(1)
-    await expect(dialog.getByRole("option", { name: new RegExp(`^${title}(?:$| )`) })).toHaveAttribute(
-      "aria-selected",
-      "true",
-    )
-    const result = await page.evaluate(() =>
-      performance.getEntriesByName("palette-result").map((entry) => entry.duration),
-    )
-    expect(result).toHaveLength(1)
-    report({ inputToResultMs: result[0] }, { home, query, data: "fixture; immediate server responses" })
-  })
-}

packages/app/e2e/performance/timeline-stability/fixture.ts

@@ -11,7 +11,6 @@ import type {
 } from "@opencode-ai/client/promise"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { SessionMessage } from "@opencode-ai/schema/session-message"
-import type { TimelineDetail } from "@opencode-ai/session-ui/timeline/detail"
 import { expect, type Page } from "@playwright/test"
 import { Schema } from "effect"
 import { mockOpenCodeServer } from "../../utils/mock-server"
@@ -123,7 +122,7 @@ export async function setupTimeline(
     messages?: TimelineMessage[]
     sessionMessages?: SessionMessageInfo[]
     sessionStatus?: Record<string, SessionStatus>
-    settings?: Record<string, boolean | TimelineDetail>
+    settings?: Record<string, boolean>
     sessions?: Session[]
     cpuRate?: number
     viewport?: { width: number; height: number }

packages/app/e2e/regression/background-read-failure.spec.ts

@@ -1,50 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block" })
-
-test("failed event-driven reads report an error and recover without an unhandled rejection", async ({ page }) => {
-  const errors: string[] = []
-  page.on("pageerror", (error) => errors.push(error.message))
-  const palette = await openCommandPalette(page)
-  const path = `**/api/session/${paletteSession.id}`
-  await page.route(path, (route) => route.abort("failed"))
-  const requested = page.waitForRequest(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_failed_refresh",
-        created: 2,
-        type: "session.viewed",
-        durable: { aggregateID: sessionID, seq: 1, version: 1 },
-        data: { sessionID, idle: 2 },
-      },
-    ])
-  }, paletteSession.id)
-  await requested
-  await expect(page.getByText("Request failed", { exact: true })).toBeVisible()
-  await palette.input.fill("copy session")
-  await expect(palette.dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await palette.input.press("Escape")
-  await page.unroute(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_recovered_refresh",
-        created: 3,
-        type: "session.renamed",
-        durable: { aggregateID: sessionID, seq: 2, version: 1 },
-        data: { sessionID, title: "Recovered session" },
-      },
-    ])
-  }, paletteSession.id)
-  await expect(page.getByRole("heading", { name: "Recovered session", exact: true })).toBeVisible()
-  expect(errors).toEqual([])
-})

packages/app/e2e/regression/command-palette.spec.ts

@@ -1,102 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", permissions: ["clipboard-read", "clipboard-write"] })
-
-test("copies the session ID while file and session searches are still pending", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const { dialog, input } = await openCommandPalette(page)
-  const release = Promise.withResolvers<void>()
-  await page.route(/\/api\/(session\?|fs\/find\?)/, async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.pressSequentially("copy session")
-  const copy = dialog.getByRole("option", { name: "Copy Session ID", exact: true })
-  await expect(copy).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe(paletteSession.id)
-  await expect(page.locator('[data-testid^="toast-v2-"] [data-slot="icon-svg"]')).toBeVisible()
-  expect(warnings).toEqual([])
-  release.resolve()
-})
-
-test("home commands do not wait for session search", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page, true)
-  const release = Promise.withResolvers<void>()
-  await page.route("**/api/session?*", async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.fill("open settings")
-  await expect(dialog.getByRole("option")).toHaveCount(1)
-  await expect(dialog.getByRole("option", { name: /^Open settings/ })).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences", exact: true })).toBeVisible()
-  release.resolve()
-})
-
-test("appends search results without resetting the selected command", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const files = Promise.withResolvers<void>()
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", async (route) => {
-    await files.promise
-    await route.fulfill({ json: { data: [{ path: "copy.txt", type: "file" }] } })
-  })
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "Copy fixture" }],
-      },
-    })
-  })
-  await input.fill("copy")
-  const project = dialog.getByRole("option", { name: "Copy Project ID", exact: true })
-  await expect(project).toBeVisible()
-  // Select a non-first command with the keyboard before remote results arrive.
-  await input.press("ArrowDown")
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  files.resolve()
-  await expect(dialog.getByRole("option", { name: "/ copy.txt", exact: true })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  // File results are usable even while sessions are still pending.
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /Copy fixture/ })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  await input.fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await expect(dialog.getByRole("option", { name: "Copy Project ID", exact: true })).toHaveCount(0)
-})
-
-test("keeps the automatically selected file when session results arrive later", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({ json: { data: [{ path: "README.md", type: "file" }] } }),
-  )
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "README work" }],
-      },
-    })
-  })
-  await input.fill("README")
-  const file = dialog.getByRole("option", { name: "/ README.md", exact: true })
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /README work/ })).toBeVisible()
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible()
-  await expect(page.getByRole("heading", { name: paletteSession.title, exact: true })).toBeVisible()
-})

packages/app/e2e/regression/command-registration.spec.ts

@@ -1,77 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", video: "off" })
-
-test("opening and closing files does not duplicate tab commands", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page)
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({
-      headers: { "access-control-allow-origin": "*" },
-      json: { data: [{ path: "fixture.txt", type: "file" }] },
-    }),
-  )
-  await palette.input.fill("fixture.txt")
-  await palette.dialog.getByRole("option", { name: /fixture\.txt/ }).click()
-  const file = page.getByRole("tab", { name: /fixture\.txt/ })
-  await expect(file).toBeVisible()
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("complementary", { name: "Review and files" })
-    .getByRole("button", { name: "Close tab", exact: true })
-    .click()
-  await expect(file).toHaveCount(0)
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  expect(warnings).toEqual([])
-})
-
-test("navigation replaces commands without retaining disposed owners", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page, true)
-  await palette.input.press("Escape")
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("region", { name: "Recent sessions" })
-    .getByRole("button", { name: /Palette fixture session/ })
-    .click()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.keyboard.press("ControlOrMeta+t")
-  await expect(page).toHaveURL(/\/new-session\?/)
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.locator('[data-component="composer-editor"]').blur()
-  await page.keyboard.press("Control+l")
-  await expect(page.locator('[data-component="composer-editor"]')).toBeFocused()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await expect(dialog.getByRole("textbox")).toHaveAttribute("placeholder", "Search files, commands, and sessions")
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveCount(0)
-  await dialog.getByRole("textbox").press("Escape")
-  await expect(dialog).toHaveCount(0)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  for (const count of [3, 4]) {
-    await page.getByRole("button", { name: "New session", exact: true }).click()
-    await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(count)
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  }
-  await page.setViewportSize({ width: 600, height: 800 })
-  await page.locator('[data-slot="mobile-tabs-trigger"]').click()
-  await expect(page.locator('[data-slot="mobile-tabs-drawer"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.setViewportSize({ width: 1280, height: 800 })
-  await expect(page.locator('[data-slot="titlebar-tabs"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.keyboard.press("ControlOrMeta+w")
-  await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(3)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  expect(warnings).toEqual([])
-})

packages/app/e2e/regression/mobile-review-summary.spec.ts

@@ -92,8 +92,6 @@ for (const direction of ["ltr", "rtl"] as const) {
       .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.mobileDiffWrap))
       .toBe(false)
     await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-    await expect(page).toHaveURL(stressSessionHref(fixture.targetID))
-    await page.getByRole("tab", { name: "Changes", exact: true }).click()
     await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "scroll")
     await expect
       .poll(() => modified.locator("[data-code]").evaluate((element) => element.scrollWidth > element.clientWidth))
@@ -116,8 +114,6 @@ for (const direction of ["ltr", "rtl"] as const) {
       .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.mobileDiffWrap))
       .toBe(true)
     await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-    await expect(page).toHaveURL(stressSessionHref(fixture.targetID))
-    await navigation.getByRole("tab", { name: "Changes", exact: true }).click()
     await expect(modified.locator("[data-diff]")).toHaveAttribute("data-overflow", "wrap")
     const openFile = modified.getByRole("button", { name: "Open file", exact: true })
     await expect(openFile).toBeVisible()

packages/app/e2e/regression/mobile-shell.spec.ts

@@ -67,7 +67,6 @@ test("mobile settings section menu stays above a full-width panel", async ({ pag
   const menu = settings.getByRole("button", { name: "Preferences", exact: true })
   const panel = settings.getByRole("tabpanel")
   await expect(settings.getByRole("heading", { name: "General", exact: true })).toBeVisible()
-  await expect(page).toHaveURL("/settings")
   await expect(menu).toBeVisible()
   await menu.click()
   await expect(page.getByRole("menuitemradio", { name: "Preferences", exact: true })).toBeChecked()
@@ -88,7 +87,6 @@ test("mobile settings section menu stays above a full-width panel", async ({ pag
     .toBe(true)
   await expect.poll(async () => (await panel.boundingBox())?.width ?? 0).toBeGreaterThan(350)
   await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-  await expect(page).toHaveURL("/")
   await expect(settings).toBeHidden()
   await expect(page.locator('[data-component="home-session-row"]')).toHaveCount(fixture.sessions.length)
 })

packages/app/e2e/regression/new-session-workspace-pending.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -26,53 +25,6 @@ for (const viewport of [
   { name: "desktop", width: 1280, height: 900 },
   { name: "mobile", width: 390, height: 844 },
 ]) {
-  test(`keeps Session in the tab until the generated title arrives on ${viewport.name}`, async ({ page }, testInfo) => {
-    await page.setViewportSize(viewport)
-    const mock = await openDraft(page, { untitled: true })
-    const label = page.locator(
-      viewport.name === "mobile"
-        ? '[data-slot="mobile-tab-title"]'
-        : '[data-titlebar-tab-slot][data-active="true"] [data-titlebar-tab-title]',
-    )
-    await expect(label).toHaveText("Session")
-    const pending = await submitPending(page, mock)
-    const spinner = page.locator(
-      viewport.name === "mobile"
-        ? '[data-slot="mobile-tabs-trigger"] [data-component="session-progress-indicator-v2"]'
-        : `[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"] [data-component="session-progress-indicator-v2"]`,
-    )
-    await expect(spinner).toBeVisible()
-    await testInfo.attach("pending-tab-title", {
-      body: await page.screenshot(),
-      contentType: "image/png",
-    })
-    await expect(label).toHaveText("Session")
-
-    mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-    await expect(pending.shimmer).toHaveCount(0)
-    await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-    await expect(label).toHaveText("Session")
-
-    if (viewport.name === "mobile") {
-      await label.click()
-      const drawer = page.locator('[data-slot="mobile-tabs-drawer"]')
-      const tab = drawer.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`)
-      await expect(tab.locator("[data-titlebar-tab-title]")).toHaveText("Session")
-      await tab.click()
-      await expect(drawer).toBeHidden()
-    }
-
-    mock.events.push({
-      id: "evt_generated_title",
-      type: "session.renamed",
-      created: Date.now(),
-      location: { directory: workspace },
-      durable: { aggregateID: pending.sessionID, seq: 1, version: 1 },
-      data: { sessionID: pending.sessionID, title: "Generated session title" },
-    })
-    await expect(label).toHaveText("Generated session title")
-  })
-
   test(`shows a pending workspace session immediately on ${viewport.name}`, async ({ page }, testInfo) => {
     await page.setViewportSize(viewport)
     const mock = await openDraft(page)
@@ -134,7 +86,7 @@ for (const viewport of [
       await expect(page).toHaveURL(pending.url)
       await expect(pending.message).toHaveAttribute("data-timeline-part-id", `${pending.messageID}:text:0`)
       await expect(pending.shimmer).toHaveAttribute("data-active", "true")
-      await expect(pending.title).toHaveText("Session")
+      await expect(pending.title).toHaveText("New session")
       await expect(editor).toHaveText(followUp)
       expect(mock.calls).toEqual(["worktree"])
 
@@ -238,7 +190,7 @@ for (const direction of ["ltr", "rtl"]) {
           !frame.message ||
           !frame.spinner ||
           frame.draft !== followUp ||
-          !["Session", "Created workspace session"].includes(frame.title ?? ""),
+          !["New session", "Created workspace session"].includes(frame.title ?? ""),
       ),
     ).toEqual([])
     const after = await title.boundingBox()
@@ -383,61 +335,6 @@ test("restores the draft after closing and revisiting a pending session that fai
   expect(mock.prompts).toEqual([])
 })
 
-test("executes a selected slash command after creating its worktree", async ({ page }, testInfo) => {
-  const events: OpenCodeEvent[] = []
-  const mock = await openDraft(page, { command: true, events: () => events.splice(0) })
-  const commands: { sessionID: string; body: Record<string, unknown> }[] = []
-  const expanded =
-    "Review the latest commit for correctness and regressions. Check the relevant tests and report actionable findings."
-  await page.route("**/api/session/*/command", async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    const sessionID = new URL(route.request().url()).pathname.split("/")[3]
-    commands.push({ sessionID, body: route.request().postDataJSON() })
-    // The server owns command expansion; the client receives the expanded inbox item.
-    events.push({
-      id: "evt_workspace_review",
-      type: "session.inbox.enqueued",
-      created: Date.now(),
-      durable: { aggregateID: sessionID, seq: 1, version: 1 },
-      data: {
-        sessionID,
-        inboxID: "msg_workspace_review",
-        item: { type: "user", payload: { text: expanded }, delivery: "steer" },
-      },
-    })
-    await route.fulfill({ status: 204, headers })
-  })
-  const editor = page.locator('[data-component="composer-editor"]')
-  await editor.fill("/review")
-  const suggestion = page.getByRole("button", { name: "/review Review changes", exact: true })
-  await expect(suggestion).toBeVisible()
-  await suggestion.click()
-  await expect(editor).toHaveText("/review")
-  const pending = await submitPending(page, mock, "/review latest commit")
-  await draftFollowUp(page)
-
-  mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-
-  await expect
-    .poll(() => commands)
-    .toEqual([
-      {
-        sessionID: pending.sessionID,
-        body: { command: "review", text: "latest commit", files: [], agents: [], skills: [], delivery: "steer" },
-      },
-    ])
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(page.locator('[data-slot="user-message-text"]')).toHaveText(expanded)
-  await expect(editor).toHaveText(followUp)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  expect(mock.creates).toEqual([expect.objectContaining({ id: pending.sessionID, location: { directory: workspace } })])
-  expect(mock.prompts).toEqual([])
-  await testInfo.attach("expanded-worktree-command", {
-    body: await page.screenshot({ path: testInfo.outputPath("expanded-worktree-command.png") }),
-    contentType: "image/png",
-  })
-})
-
 async function draftFollowUp(page: Page) {
   const editor = page.locator('[data-component="composer-editor"]')
   await editor.pressSequentially("!")
@@ -449,16 +346,12 @@ async function draftFollowUp(page: Page) {
   await expect(editor).toHaveText(followUp)
 }
 
-async function openDraft(
-  page: Page,
-  options?: { failSessionCreate?: boolean; untitled?: boolean; command?: boolean; events?: () => OpenCodeEvent[] },
-) {
+async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
   const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
   const calls: string[] = []
   const worktreeRequests: Record<string, unknown>[] = []
   const creates: Record<string, unknown>[] = []
   const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
-  const events: OpenCodeEvent[] = []
   const project = {
     id: projectID,
     worktree: directory,
@@ -485,7 +378,6 @@ async function openDraft(
     sessions,
     pageMessages: () => ({ items: [] }),
     onPrompt: (input) => prompts.push(input),
-    events: options?.events ?? (() => events.splice(0)),
   })
   page.on("request", (request) => {
     if (request.method() !== "POST") return
@@ -512,10 +404,7 @@ async function openDraft(
       return route.fulfill({ status: 500, json: { message: "Session creation failed in the fixture" }, headers })
     }
     if (typeof body.id !== "string") throw new Error("Session creation must use the client-reserved ID")
-    const session = currentSession(
-      { ...body, id: body.id, projectID, title: options?.untitled ? "" : "Created workspace session" },
-      workspace,
-    )
+    const session = currentSession({ ...body, id: body.id, projectID, title: "Created workspace session" }, workspace)
     sessions.push(session)
     return route.fulfill({ json: { data: session }, headers })
   })
@@ -547,17 +436,6 @@ async function openDraft(
       headers,
     }),
   )
-  if (options?.command) {
-    await page.route("**/api/command?**", (route) =>
-      route.fulfill({
-        json: {
-          location: { directory: new URL(route.request().url()).searchParams.get("location[directory]") ?? directory },
-          data: [{ name: "review", description: "Review changes" }],
-        },
-        headers,
-      }),
-    )
-  }
   await page.addInitScript(
     ({ directory, draftID, otherID, server }) => {
       localStorage.setItem(
@@ -583,11 +461,11 @@ async function openDraft(
   await page.getByRole("menuitem", { name: "New worktree", exact: true }).click()
   await expect(page.getByRole("button", { name: "New worktree", exact: true })).toBeVisible()
   await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  return { worktree, worktreeRequests, calls, creates, prompts, events }
+  return { worktree, worktreeRequests, calls, creates, prompts }
 }
 
-async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>, prompt = text) {
-  await page.locator('[data-component="composer-editor"]').fill(prompt)
+async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
+  await page.locator('[data-component="composer-editor"]').fill(text)
   await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
   await page.locator('[data-action="composer-submit"]').click()
   await expect(page).toHaveURL((url) => url.pathname.startsWith(sessionPath) && /\/ses_[^/]+$/.test(url.pathname))
@@ -598,12 +476,12 @@ async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDra
   const shimmer = preparing.getByRole("status").locator('[data-component="text-shimmer"]')
   const title = preparing.getByRole("heading", { level: 1 })
   await expect(preparing).toBeVisible()
-  await expect(title).toHaveText("Session")
+  await expect(title).toHaveText("New session")
   await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
   await expect(page.locator('[data-action="composer-submit"]')).toBeDisabled()
   await expect(preparing.locator('[data-component="user-message"]')).toHaveCount(1)
   await expect(message).toHaveCount(1)
-  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(prompt)
+  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(text)
   await expect(message).toHaveAttribute("data-timeline-part-id", /^.+:text:0$/)
   const messageID = (await message.getAttribute("data-timeline-part-id"))!.replace(/:text:0$/, "")
   await expect(shimmer).toBeVisible()

packages/app/e2e/regression/remote-session-settings.spec.ts

@@ -30,11 +30,9 @@ test("session settings use the remote server context", async ({ page }) => {
 
   const settings = page.getByTestId("settings-screen")
   await expect(settings).toBeVisible()
-  await expect(page).toHaveURL("/settings")
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toHaveCount(0)
-  await expect(page.getByRole("button", { name: "Home", exact: true })).toHaveAttribute("aria-pressed", "false")
   await expect(page.getByRole("dialog")).toHaveCount(0)
   await expect(settings.getByRole("tablist")).toHaveCSS("width", "328px")
+  await expect(sessionHeading).toBeAttached()
   await expect(sessionHeading).toBeHidden()
   const autoAccept = settings.locator('[data-action="settings-auto-accept-permissions"]')
   const input = autoAccept.getByRole("switch")
@@ -68,15 +66,6 @@ test("session settings use the remote server context", async ({ page }) => {
   await expect(settings.getByRole("switch", { name: "Server A Model" })).toHaveCount(0)
   await settings.getByRole("button", { name: "Back to app" }).click()
   await expect(settings).toBeHidden()
-  await expect(page).toHaveURL(`/server/${base64Encode(serverB)}/session/${sessionB.id}`)
-  await expect(sessionHeading).toBeVisible()
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toContainText(sessionB.title)
-  await page.keyboard.press("Control+]")
-  await expect(page).toHaveURL("/settings")
-  await expect(settings.getByRole("tab", { name: "Models", exact: true })).toHaveAttribute("aria-selected", "true")
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toHaveCount(0)
-  await page.keyboard.press("Escape")
-  await expect(page).toHaveURL(`/server/${base64Encode(serverB)}/session/${sessionB.id}`)
   await expect(sessionHeading).toBeVisible()
 })
 

packages/app/e2e/regression/remote-tab-busy.spec.ts

@@ -1,7 +1,6 @@
-import { expect, test, type Page } from "@playwright/test"
+import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
-import { createMockServerHandler } from "../utils/mock-server"
-import { installSseTransport } from "../utils/sse-transport"
+import { currentSession } from "../utils/mock-server"
 
 const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const serverB = "http://127.0.0.1:4097"
@@ -9,8 +8,6 @@ const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
 const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
 const childB = { ...session("ses_server_b_child", sessionB.directory, "Server B subagent"), parentID: sessionB.id }
 
-test.use({ serviceWorkers: "block" })
-
 test("tab busy indicator reflects activity in the tab session family", async ({ page }, info) => {
   await mockServers(page)
   await page.addInitScript(
@@ -30,7 +27,7 @@ test("tab busy indicator reflects activity in the tab session family", async ({
   const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
   const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
   await page.goto(hrefB)
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
 
   // The parent is idle, but its tab remains active while the background child runs.
   const tabB = page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefB}"])`)
@@ -55,61 +52,65 @@ function session(id: string, directory: string, title: string) {
 }
 
 async function mockServers(page: Page) {
-  // Both servers stay connected while the client hydrates their active-session snapshots.
-  await installSseTransport(page, { server: serverA })
-  await installSseTransport(page, { server: serverB })
-  const servers = new Map(
-    [sessionA, sessionB].map(
-      (current) =>
-        [
-          current === sessionA ? serverA : serverB,
-          createMockServerHandler({
-            directory: current.directory,
-            project: {
-              id: current.projectID,
-              worktree: current.directory,
-              vcs: "git",
-              time: { created: 1, updated: 1 },
-              sandboxes: [],
-            },
-            sessions: current === sessionB ? [current, childB] : [current],
-            sessionStatus: current === sessionB ? { [childB.id]: { type: "running" } } : {},
-            provider: { all: [], connected: [], default: {} },
-            pageMessages: () => ({ items: [] }),
-          }),
-        ] as const,
-    ),
-  )
-  page.on("close", () => servers.forEach((server) => void server.dispose()))
   await page.route("**/api/**", async (route) => {
     const url = new URL(route.request().url())
-    const server = servers.get(url.origin)
-    if (!server) return route.fallback()
+    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
     const current = url.origin === serverA ? sessionA : sessionB
     const directory = url.searchParams.get("directory")
-    if (directory && directory !== current.directory)
-      return route.fulfill({
-        status: 500,
-        json: { name: "InvalidDirectory" },
-        headers: { "access-control-allow-origin": "*" },
+    if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
+    if (url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/api/health") return json(route, { pid: 1 })
+    if (url.pathname === "/api/session/active")
+      return json(route, { data: url.origin === serverB ? { [childB.id]: { type: "running" } } : {} })
+    if (url.pathname === "/api/session")
+      return json(route, {
+        data: url.origin === serverB ? [currentSession(current), currentSession(childB)] : [currentSession(current)],
+        cursor: {},
       })
-    if (route.request().method() === "OPTIONS")
-      return route.fulfill({
-        status: 204,
-        headers: { "access-control-allow-origin": "*", "access-control-allow-headers": "*" },
+    if (url.pathname === `/api/session/${current.id}`) return json(route, { data: currentSession(current) })
+    if (url.pathname === `/api/session/${current.id}/message`) return json(route, { data: [], cursor: {} })
+    if (["/api/agent", "/api/provider", "/api/model", "/api/command", "/api/reference"].includes(url.pathname))
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/model/default")
+      return json(route, { location: { directory: current.directory }, data: null })
+    if (url.pathname === "/api/permission/request" || url.pathname === "/api/question/request")
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp") return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp/resource")
+      return json(route, { location: { directory: current.directory }, data: { resources: [], templates: [] } })
+    if (url.pathname === "/api/project" || url.pathname === "/api/project/current") {
+      const project = {
+        id: current.projectID,
+        canonical: current.directory,
+        vcs: "git",
+        time: { created: 1, updated: 1 },
+        sandboxes: [],
+      }
+      return json(route, url.pathname === "/api/project" ? [project] : { id: project.id, directory: current.directory })
+    }
+    if (url.pathname === "/api/location") return json(route, { directory: current.directory })
+    if (url.pathname === "/api/vcs")
+      return json(route, {
+        location: { directory: current.directory },
+        data: { branch: "main", defaultBranch: "main" },
       })
-    const body = route.request().postDataBuffer()
-    const response = await server.handler(
-      new Request(url, {
-        method: route.request().method(),
-        headers: route.request().headers(),
-        body: body ? Uint8Array.from(body) : undefined,
-      }),
-    )
-    return route.fulfill({
-      status: response.status,
-      headers: { ...Object.fromEntries(response.headers), "access-control-allow-origin": "*" },
-      body: Buffer.from(await response.arrayBuffer()),
-    })
+    return json(route, {})
+  })
+}
+
+function json(route: Route, body: unknown, status = 200) {
+  return route.fulfill({
+    status,
+    contentType: "application/json",
+    headers: { "access-control-allow-origin": "*" },
+    body: JSON.stringify(body),
+  })
+}
+
+function sse(route: Route) {
+  return route.fulfill({
+    status: 200,
+    contentType: "text/event-stream",
+    body: 'data: {"id":"evt_connected","type":"server.connected","data":{}}\n\n',
   })
 }

packages/app/e2e/regression/review-open-file.spec.ts

@@ -92,16 +92,10 @@ test("opens and searches project files inline", async ({ page }) => {
   const contextButton = page.getByRole("button", { name: "View context usage" })
   await contextButton.click()
   await expect(panel.getByRole("tab", { name: "Context", selected: true })).toBeVisible()
-  await expect(panel.getByRole("button", { name: "Open file" }).locator("use")).toHaveAttribute(
-    "href",
-    "#opencode-v2-icon-plus",
-  )
   await panel.getByRole("button", { name: "Open file" }).click()
   const openFileTab = panel.getByRole("tab", { name: "Open file" })
   const openFileTabClose = openFileTab.locator("..").getByRole("button", { name: "Close tab" })
   await expect(openFileTab).toHaveAttribute("data-selected", "")
-  await expect(openFileTab.locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(openFileTab.locator("..")).toHaveCSS("gap", "8px")
   await expect(openFileTab.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-file-tree")
   await expect(openFileTab.getByText("Open file", { exact: true }).locator("..")).not.toHaveClass(/italic/)
   await expect(openFileTabClose).toHaveAttribute("data-variant", "ghost-muted")
@@ -120,8 +114,6 @@ test("opens and searches project files inline", async ({ page }) => {
 
   await panel.getByRole("button", { name: "README.md" }).click()
   await expect(panel.getByRole("tab", { name: "README.md", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("gap", "8px")
   await expect(sidebarToggle).toBeEnabled()
   await expect(panel.getByText("contents:README.md", { exact: true })).toBeVisible()
   await expect(sidebar).toHaveCount(0)
@@ -137,8 +129,6 @@ test("opens and searches project files inline", async ({ page }) => {
   await expect(filter).toHaveAttribute("aria-activedescendant", resultID!)
   await filter.press("Enter")
   await expect(panel.getByRole("tab", { name: "nested.ts", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("gap", "8px")
   await expect(sidebarToggle).toBeEnabled()
   await expect(panel.getByText("contents:src/nested.ts", { exact: true })).toBeVisible()
   expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200 })

packages/app/e2e/regression/review-toggle-position.spec.ts

@@ -1,189 +0,0 @@
-import { base64Encode } from "@opencode-ai/util/encode"
-import { expect, test, type Locator } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/ReviewTogglePosition"
-const sessionID = "ses_review_toggle_position"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_review_toggle_position",
-      worktree: directory,
-      vcs: "git",
-      name: "review-toggle-position",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "review-toggle-position",
-        projectID: "proj_review_toggle_position",
-        directory,
-        title: "Review toggle position",
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-  })
-})
-
-for (const width of [1000, 1440]) {
-  for (const direction of ["ltr", "rtl"] as const) {
-    test(`keeps the review toggle at the outer header edge (${width}px, ${direction})`, async ({ page }) => {
-      await page.setViewportSize({ width, height: 900 })
-      await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-      await expectSessionTitle(page, "Review toggle position")
-      await page.locator("html").evaluate((element, dir) => element.setAttribute("dir", dir), direction)
-
-      const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
-      const header = page.locator("[data-session-title]")
-      const panel = page.locator("#review-panel")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      const closed = await toggle.boundingBox()
-      if (!closed) throw new Error("Review toggle bounds are unavailable")
-      const headerBox = await header.boundingBox()
-      if (!headerBox) throw new Error("Session header bounds are unavailable")
-      expect(closed.y).toBeGreaterThanOrEqual(headerBox.y)
-      expect(closed.y + closed.height).toBeLessThanOrEqual(headerBox.y + headerBox.height)
-
-      await toggle.click()
-      await expect(toggle).toHaveAttribute("aria-expanded", "true")
-      await expect(panel).toHaveAttribute("aria-hidden", "false")
-      await expect(toggle).toHaveCount(1)
-      await expect.poll(() => toggle.boundingBox()).toEqual(closed)
-      await expect
-        .poll(async () => {
-          const box = await panel.boundingBox()
-          if (!box) return false
-          return (
-            closed.x >= box.x &&
-            closed.x + closed.width <= box.x + box.width &&
-            closed.y >= box.y &&
-            closed.y + closed.height <= box.y + 52
-          )
-        })
-        .toBe(true)
-
-      await expect
-        .poll(async () => {
-          const box = await panel.locator('[data-slot="session-side-panel-actions"]').boundingBox()
-          return box ? box.y + box.height / 2 : undefined
-        })
-        .toBe(closed.y + closed.height / 2)
-
-      await toggle.press("Enter")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await expect(toggle).toBeFocused()
-      await expect(toggle).toHaveCount(1)
-      await expect.poll(() => toggle.boundingBox()).toEqual(closed)
-    })
-
-    test(`keeps terminal controls clear of the review toggle (${width}px, ${direction})`, async ({ page }) => {
-      await page.setViewportSize({ width, height: 900 })
-      const ptys: { id: string; title: string }[] = []
-      const removed: string[] = []
-      await page.route("**/api/pty**", async (route) => {
-        const path = new URL(route.request().url()).pathname
-        const location = { directory, project: { id: "proj_review_toggle_position", directory } }
-        if (route.request().method() === "DELETE") {
-          removed.push(path.split("/").at(-1)!)
-          return route.fulfill({ status: 204 })
-        }
-        if (path.endsWith("/connect-token")) {
-          return route.fulfill({ json: { location, data: { ticket: "e2e-ticket", expires_in: 60 } } })
-        }
-        if (path === "/api/pty" && route.request().method() === "POST") {
-          const pty = { id: `pty_review_${ptys.length + 1}`, title: `Terminal ${ptys.length + 1}` }
-          ptys.push(pty)
-          return route.fulfill({ json: { location, data: pty } })
-        }
-        return route.fulfill({ json: { location, data: ptys.find((pty) => path.endsWith(pty.id)) ?? ptys } })
-      })
-      await page.routeWebSocket(/\/api\/pty\/pty_review_\d+\/connect/, () => undefined)
-      await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-      await expectSessionTitle(page, "Review toggle position")
-      await page.locator("html").evaluate((element, dir) => element.setAttribute("dir", dir), direction)
-
-      const toggle = page.getByRole("button", { name: "Toggle review", exact: true })
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await page.keyboard.press("Control+Backquote")
-      const terminal = page.getByRole("region", { name: "Terminal", exact: true })
-      await expect(terminal.getByRole("tab", { name: "Terminal 1", exact: true })).toHaveAttribute(
-        "aria-selected",
-        "true",
-      )
-      for (const number of [2, 3, 4]) {
-        await terminal.getByRole("button", { name: "New terminal", exact: true }).click()
-        await expect(terminal.getByRole("tab", { name: `Terminal ${number}`, exact: true })).toHaveAttribute(
-          "aria-selected",
-          "true",
-        )
-      }
-
-      await expect
-        .poll(async () => {
-          const tabs = await terminal.getByRole("tablist").boundingBox()
-          const button = await toggle.boundingBox()
-          if (!tabs || !button) return false
-          return direction === "rtl" ? tabs.x >= button.x + button.width : tabs.x + tabs.width <= button.x
-        })
-        .toBe(true)
-      await expectTerminalControlsAligned(terminal, toggle)
-      const fourth = terminal.locator('[data-slot="tabs-trigger-wrapper"][data-value="pty_review_4"]')
-      await fourth.getByRole("button", { name: "Close terminal", exact: true }).click()
-      await expect(terminal.getByRole("tab")).toHaveText(["Terminal 1", "Terminal 2", "Terminal 3"])
-      expect(removed).toEqual(["pty_review_4"])
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-
-      await terminal.getByRole("button", { name: "New terminal", exact: true }).click()
-      await expect(terminal.getByRole("tab", { name: "Terminal 5", exact: true })).toHaveAttribute(
-        "aria-selected",
-        "true",
-      )
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      const position = await toggle.boundingBox()
-      await toggle.click()
-      await expect(toggle).toHaveAttribute("aria-expanded", "true")
-      await expect(page.locator("#review-panel")).toHaveAttribute("aria-hidden", "false")
-      await expect.poll(() => toggle.boundingBox()).toEqual(position)
-      await expect
-        .poll(async () => {
-          const actions = await page.locator('[data-slot="session-side-panel-actions"]').boundingBox()
-          const button = await toggle.boundingBox()
-          if (!actions || !button) return undefined
-          return actions.y + actions.height / 2 - (button.y + button.height / 2)
-        })
-        .toBe(0)
-      await toggle.press("Enter")
-      await expect(toggle).toHaveAttribute("aria-expanded", "false")
-      await expect(toggle).toBeFocused()
-      await expect.poll(() => toggle.boundingBox()).toEqual(position)
-      await expectTerminalControlsAligned(terminal, toggle)
-    })
-  }
-}
-
-async function expectTerminalControlsAligned(terminal: Locator, toggle: Locator) {
-  await expect
-    .poll(async () => {
-      const centers = await Promise.all(
-        [terminal.getByRole("button", { name: "New terminal", exact: true }), toggle].map((button) =>
-          button.locator("svg").evaluate((element) => {
-            const svg = element as SVGSVGElement
-            const path = svg.getBBox()
-            return new DOMPoint(path.x + path.width / 2, path.y + path.height / 2).matrixTransform(svg.getScreenCTM()!)
-              .y
-          }),
-        ),
-      )
-      return centers[0]! - centers[1]!
-    })
-    .toBeCloseTo(0, 1)
-}

packages/app/e2e/regression/session-header-controls.spec.ts

@@ -23,8 +23,7 @@ for (const direction of ["ltr", "rtl"] as const) {
     await page.goto(stressSessionHref(fixture.targetID))
     const header = page.locator("[data-session-title]")
     const more = header.getByRole("button", { name: "More options", exact: true })
-    const project = header.getByRole("button", { name: fixture.project.name, exact: true })
-    const review = page.getByRole("button", { name: "Toggle review", exact: true })
+    const review = header.getByRole("button", { name: "Toggle review", exact: true })
     const details = header.getByRole("button", { name: "Session details", exact: true })
     await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
     await page.evaluate((direction) => document.documentElement.setAttribute("dir", direction), direction)
@@ -32,40 +31,22 @@ for (const direction of ["ltr", "rtl"] as const) {
     await expect(details).toBeVisible()
     const status = page.locator('[data-slot="titlebar-v2"]').getByRole("button", { name: "Status" })
     await expect(status).toBeVisible()
-    const titleBounds = await header.getByRole("heading").boundingBox()
-    expect(titleBounds).not.toBeNull()
-    for (const editing of [false, true]) {
-      if (editing) {
-        await header.getByRole("heading").click()
-        await expect(header.getByRole("textbox")).toHaveValue(fixture.expected.targetTitle)
-        await expect(header.getByRole("textbox")).toBeFocused()
-      }
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-left", "4px")
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-right", "4px")
-      await expect
-        .poll(async () => {
-          const boxes = await Promise.all(
-            [project, header.locator('[data-slot="session-title-child"]'), more, review, details].map((control) =>
-              control.boundingBox(),
-            ),
-          )
-          const [icon, title, menu, sidebar, summary] = boxes
-          if (!icon || !title || !menu || !sidebar || !summary || !titleBounds) return false
-          if (Math.abs(title.y - titleBounds.y) > 0.5 || Math.abs(title.height - titleBounds.height) > 0.5) return false
-          return direction === "ltr"
-            ? Math.abs(title.x - icon.x - icon.width - 2) <= 0.5 &&
-                Math.abs(menu.x - title.x - title.width - 2) <= 0.5 &&
-                menu.x + menu.width <= summary.x &&
-                summary.x + summary.width <= sidebar.x
-            : Math.abs(icon.x - title.x - title.width - 2) <= 0.5 &&
-                Math.abs(title.x - menu.x - menu.width - 2) <= 0.5 &&
-                sidebar.x + sidebar.width <= summary.x &&
-                summary.x + summary.width <= menu.x
-        })
-        .toBe(true)
-    }
-    await header.getByRole("textbox").press("Escape")
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
+    await expect
+      .poll(async () => {
+        const boxes = await Promise.all(
+          [header.getByRole("heading"), more, review, details].map((button) => button.boundingBox()),
+        )
+        const [title, menu, sidebar, summary] = boxes
+        if (!title || !menu || !sidebar || !summary) return false
+        return direction === "ltr"
+          ? Math.abs(title.x + title.width - menu.x) <= 1 &&
+              menu.x + menu.width <= summary.x &&
+              summary.x + summary.width <= sidebar.x
+          : Math.abs(menu.x + menu.width - title.x) <= 1 &&
+              sidebar.x + sidebar.width <= summary.x &&
+              summary.x + summary.width <= menu.x
+      })
+      .toBe(true)
 
     await review.click()
     await expect(review).toHaveAttribute("aria-expanded", "true")
@@ -74,52 +55,6 @@ for (const direction of ["ltr", "rtl"] as const) {
     await expect(review).toHaveAttribute("aria-expanded", "false")
 
     await more.click()
-    const options = page.getByRole("menu")
-    await expect(options.getByRole("menuitem")).toHaveText(["Rename", "Export…", "Delete…"])
-    if (direction === "ltr") {
-      await expect
-        .poll(async () => {
-          const [button, menu] = await Promise.all([
-            header.getByRole("button", { name: "More options", exact: true, includeHidden: true }).boundingBox(),
-            options.boundingBox(),
-          ])
-          return button && menu ? Math.abs(button.x - menu.x) : Infinity
-        })
-        .toBeLessThanOrEqual(1)
-    }
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const rtl = getComputedStyle(element).direction === "rtl"
-          return Math.min(
-            ...Array.from(element.querySelectorAll('[data-slot="menu-v2-item-content"]'), (label) => {
-              const range = document.createRange()
-              range.selectNodeContents(label)
-              const text = range.getBoundingClientRect()
-              return rtl ? text.left - menu.left : menu.right - text.right
-            }),
-          )
-        }),
-      )
-      .toBeCloseTo(32, 0)
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const divider = element.querySelector('[data-slot="menu-v2-separator"]')?.getBoundingClientRect()
-          const rows = Array.from(element.querySelectorAll('[role="menuitem"]'), (row) => row.getBoundingClientRect())
-          return (
-            !!divider &&
-            Math.abs(divider.left - menu.left) <= 0.5 &&
-            Math.abs(divider.right - menu.right) <= 0.5 &&
-            rows.every(
-              (row) => Math.abs(row.left - menu.left - 2) <= 0.5 && Math.abs(menu.right - row.right - 2) <= 0.5,
-            )
-          )
-        }),
-      )
-      .toBe(true)
     await expect(page.getByRole("menuitem", { name: "Server status", exact: true })).toHaveCount(0)
     await page.keyboard.press("Escape")
     await status.click()

packages/app/e2e/regression/session-location-sync.spec.ts

@@ -67,12 +67,6 @@ test("follows a live session move while the agent catalog is still loading", asy
   const session = { id: sessionID, projectID: fixture.project.id, directory, title: "Moved session" }
   const requested = Promise.withResolvers<void>()
   const release = Promise.withResolvers<void>()
-  await page.addInitScript(() => {
-    localStorage.setItem(
-      "settings.v3",
-      JSON.stringify({ general: { timelineDetail: { notices: { placement: "separate" } } } }),
-    )
-  })
   const transport = await installSseTransport(page, { server: fixture.serverKey })
   await mockOpenCodeServer(page, {
     directory: fixture.directory,
@@ -101,7 +95,9 @@ test("follows a live session move while the agent catalog is still loading", asy
   await transport.waitForConnection()
   const resolved = page.waitForResponse((response) => {
     const url = new URL(response.url())
-    return url.pathname === "/api/agent" && url.searchParams.get("location[directory]") === destination && response.ok()
+    return (
+      url.pathname === "/api/agent" && url.searchParams.get("location[directory]") === destination && response.ok()
+    )
   })
   session.directory = destination
   await transport.send({
@@ -225,8 +221,7 @@ function recoveryRequests(page: Page) {
   const requests: string[] = []
   page.on("request", (request) => {
     const path = new URL(request.url()).pathname
-    if (request.method() === "POST" && /^\/api\/(session\/[^/]+\/move$|worktree(?:\/|$))/.test(path))
-      requests.push(path)
+    if (request.method() === "POST" && /^\/api\/(session\/[^/]+\/move$|worktree(?:\/|$))/.test(path)) requests.push(path)
   })
   return requests
 }

packages/app/e2e/regression/session-notice-truncation.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import { setupTimeline } from "../performance/timeline-stability/fixture"
 
 for (const width of [1400, 390]) {
@@ -17,9 +16,6 @@ for (const width of [1400, 390]) {
         `\u0645\u0631\u0627\u062c\u0639\u0629 ${command}--reviewed`,
       ]
       await setupTimeline(page, {
-        settings: {
-          timelineDetail: { ...timelinePresets[2].value, notices: { placement: "separate" } },
-        },
         locale: profile.locale,
         viewport: { width, height: 900 },
         sessionMessages: [

packages/app/e2e/regression/session-project-menu.spec.ts

@@ -1,327 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { dict } from "../../src/runtime/i18n/ar"
-import en from "../../src/runtime/i18n/en"
-import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
-import { installStressSessionTabs, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ serviceWorkers: "block" })
-
-for (const direction of ["ltr", "rtl"] as const) {
-  for (const workspace of [false, true]) {
-    test(`session project menu for ${workspace ? "worktree" : "local"} in ${direction}`, async ({ page }) => {
-      const copy = direction === "rtl" ? dict : en
-      const directory = workspace
-        ? "C:/OpenCode/Worktrees/مشروع-42/long-folder-name-for-checking-wrapped-worktree-paths/another-long-folder-name-to-exercise-the-full-path-tooltip"
-        : fixture.directory
-      const project = {
-        ...fixture.project,
-        name: workspace
-          ? "مشروع Timeline 42 with a long project name that needs truncation and enough additional text to wrap inside the tooltip"
-          : "Timeline project",
-        sandboxes: workspace ? [directory] : [],
-        icon: {
-          url: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><circle cx="8" cy="8" r="7" fill="blue"/></svg>')}`,
-        },
-      }
-      await mockOpenCodeServer(page, {
-        directory,
-        project,
-        sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-        provider: fixture.provider,
-        pageMessages,
-      })
-      await installStressSessionTabs(page)
-      await page.addInitScript((direction) => {
-        localStorage.setItem(
-          "opencode.global.dat:language",
-          JSON.stringify({ locale: direction === "rtl" ? "ar" : "en" }),
-        )
-        const settings = JSON.parse(localStorage.getItem("settings.v3") ?? "{}")
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({ ...settings, general: { ...settings.general, showProjectIcon: false } }),
-        )
-      }, direction)
-      await page.setViewportSize({ width: workspace ? 900 : 1440, height: 900 })
-      await page.goto(stressSessionHref(fixture.targetID))
-      const header = page.locator("[data-session-title]")
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-      await expect(page.locator("html")).toHaveAttribute("dir", direction)
-
-      const trigger = header.getByRole("button", { name: project.name, exact: true })
-      await expect(trigger).toBeEnabled()
-      await expect(trigger.locator("use")).toHaveAttribute(
-        "href",
-        `#opencode-v2-icon-${workspace ? "workspace-isolated" : "monitor"}`,
-      )
-      const background = await trigger.evaluate((element) => getComputedStyle(element).backgroundColor)
-      await trigger.hover()
-      await expect(trigger).not.toHaveCSS("background-color", background)
-      await expect(page.getByRole("tooltip")).toHaveText(project.name)
-      await trigger.click()
-
-      const menu = page.getByRole("menu", { name: project.name, exact: true })
-      const settings = menu.getByRole("menuitem", { name: "Edit project", exact: true })
-      const projectItem = menu.getByRole("menuitem", { name: project.name, exact: true })
-      await expect(trigger).toHaveAttribute("aria-expanded", "true")
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await expect(menu.getByText(project.name, { exact: true })).toBeVisible()
-      await expect(menu.locator('[data-slot="project-avatar-image"]')).toHaveAttribute("src", project.icon.url)
-      await expect(menu.getByText(directory, { exact: true })).toBeVisible()
-      await expect(menu.getByText(directory, { exact: true })).toHaveAttribute("dir", "ltr")
-      await expect(menu.locator('use[href="#opencode-v2-icon-folder"]')).toHaveCount(1)
-      await expect(menu).toHaveCSS("direction", direction)
-      await expect(menu.getByRole("menuitem")).toHaveText([project.name, directory, "Edit project"])
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await expect(settings).toBeEnabled()
-      await expect
-        .poll(() => menu.evaluate((element) => element.getBoundingClientRect().width))
-        .toBeLessThanOrEqual(320)
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        await expect(label).toHaveCSS("text-overflow", "ellipsis")
-        await expect(label).toHaveCSS("white-space", "nowrap")
-        if (workspace) {
-          await expect.poll(() => label.evaluate((element) => element.scrollWidth > element.clientWidth)).toBe(true)
-        }
-      }
-      await expect.poll(() => menu.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
-      const icons = menu.locator(
-        '[data-component="project-avatar-v2"], [data-slot="icon-svg"]:not([data-slot="session-project-open-icon"] *)',
-      )
-      await expect(icons).toHaveCount(3)
-      await expect
-        .poll(async () => {
-          const [button, centers] = await Promise.all([
-            trigger.boundingBox(),
-            icons.evaluateAll((elements) =>
-              elements.map((element) => {
-                const box = element.getBoundingClientRect()
-                return box.x + box.width / 2
-              }),
-            ),
-          ])
-          return !!button && centers.every((center) => Math.abs(center - button.x - button.width / 2) <= 1)
-        })
-        .toBe(true)
-
-      if (!workspace) await page.clock.install()
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        const item = menu.getByRole("menuitem", { name: text, exact: true })
-        const anchor = item.locator("..")
-        const openIcon = item.locator('[data-slot="session-project-open-icon"]')
-        const content = item.locator(".session-project-link-content")
-        const width = await label.evaluate((element) => element.getBoundingClientRect().width)
-        await expect(openIcon).toHaveCount(text === directory ? 1 : 0)
-        await anchor.hover()
-        await expect(content).toHaveCSS("mask-image", "none")
-        await expect.poll(() => label.evaluate((element) => element.getBoundingClientRect().width)).toBe(width)
-        if (text === directory) {
-          await expect(openIcon).toHaveCSS("opacity", "0")
-          await expect(openIcon.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-arrow-up-right")
-          await expect
-            .poll(() => openIcon.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-            .toBeGreaterThan(0)
-          await expect
-            .poll(async () => {
-              const [row, icon] = await Promise.all([item.boundingBox(), openIcon.boundingBox()])
-              if (!row || !icon) return false
-              return (
-                Math.abs(row.y + row.height / 2 - icon.y - icon.height / 2) <= 0.5 &&
-                Math.abs((direction === "rtl" ? icon.x - row.x : row.x + row.width - icon.x - icon.width) - 12) <= 0.5
-              )
-            })
-            .toBe(true)
-        }
-        await expect(label).toHaveCSS("cursor", "default")
-        await expect(anchor).toHaveCSS("cursor", "default")
-        const tooltip = page.getByRole("tooltip")
-        if (workspace) {
-          await expect(tooltip).toHaveText(text)
-          await expect(tooltip).toHaveCSS("white-space", "normal")
-          await expect
-            .poll(() => tooltip.evaluate((element) => element.getBoundingClientRect().width))
-            .toBeLessThanOrEqual(480)
-          await expect
-            .poll(() =>
-              tooltip
-                .getByText(text, { exact: true })
-                .evaluate(
-                  (element) =>
-                    element.getBoundingClientRect().height > Number.parseFloat(getComputedStyle(element).lineHeight),
-                ),
-            )
-            .toBe(true)
-          await expect
-            .poll(async () => {
-              const [row, tip] = await Promise.all([anchor.boundingBox(), tooltip.boundingBox()])
-              return !!row && !!tip && Math.abs(row.y - tip.y - tip.height - 2) <= 1
-            })
-            .toBe(true)
-        }
-        if (!workspace) {
-          await page.clock.runFor(500)
-          await expect(tooltip).toBeHidden()
-        }
-        await settings.hover()
-        await expect(tooltip).toBeHidden()
-        if (text === directory) await expect(openIcon).toHaveCSS("opacity", "0")
-        await expect(content).toHaveCSS("mask-image", "none")
-      }
-
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      const pathItem = menu.getByRole("menuitem", { name: directory, exact: true })
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("Enter")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Space")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("ArrowDown")
-      await expect(settings).toBeFocused()
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await page.keyboard.press("Enter")
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("heading", { name: copy["dialog.project.edit.title"], exact: true })).toBeVisible()
-      await expect(dialog.getByRole("textbox", { name: copy["dialog.project.edit.name"], exact: true })).toHaveValue(
-        project.name,
-      )
-      await expect(menu).toBeHidden()
-      await dialog.getByRole("button", { name: copy["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-
-      await page.setViewportSize({ width: 1440, height: 900 })
-      for (const selected of [false, true]) {
-        if (selected) {
-          await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-          await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-        }
-        await trigger.click()
-        await expect(projectItem).toBeEnabled()
-        const background = await projectItem.evaluate((element) => getComputedStyle(element).backgroundColor)
-        await projectItem.hover()
-        await expect(projectItem).not.toHaveCSS("background-color", background)
-        await projectItem.click()
-        await expect(page).toHaveURL(new URL("/", page.url()).href)
-        await expect(menu).toBeHidden()
-        const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: project.name })
-        await expect(projectRow).toBeVisible()
-        await expect(projectRow).toHaveAttribute("data-selected", "")
-        await expect(
-          page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-        ).toBeVisible()
-      }
-    })
-  }
-}
-
-for (const state of ["closed", "unopened"] as const) {
-  test(`session project menu restores ${state} projects before and after messages load`, async ({ page }) => {
-    const directory = "C:/OpenCode/Worktrees/project-menu-recovery"
-    const messages = Promise.withResolvers<void>()
-    await mockOpenCodeServer(page, {
-      directory,
-      project: { ...fixture.project, sandboxes: [directory] },
-      sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-      provider: fixture.provider,
-      pageMessages,
-      beforeMessagesResponse: (input) => (input.sessionID === fixture.targetID ? messages.promise : Promise.resolve()),
-    })
-    await page.setViewportSize({ width: 1440, height: 900 })
-    if (state === "closed") {
-      await installStressSessionTabs(page)
-      await page.goto("/")
-      const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-      await expect(projectRow).toBeEnabled()
-      await projectRow.locator("..").getByRole("button", { name: "More options", exact: true }).click()
-      await page.getByRole("menuitem", { name: "Close", exact: true }).click()
-      await expect(projectRow).toHaveCount(0)
-      await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-    }
-    if (state === "unopened") await page.goto(stressSessionHref(fixture.targetID))
-
-    const header = page.locator("[data-session-title]")
-    const trigger = header.getByRole("button", { name: fixture.project.name, exact: true })
-    const menu = page.getByRole("menu", { name: fixture.project.name, exact: true })
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-    for (const loaded of [false, true]) {
-      if (loaded) {
-        messages.resolve()
-        await expect(header.getByRole("button", { name: "More options", exact: true })).toBeVisible()
-      }
-      await expect(trigger.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-workspace-isolated")
-      await trigger.click()
-      await expect(menu.getByRole("menuitem", { name: fixture.project.name, exact: true })).toBeEnabled()
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await menu.getByRole("menuitem", { name: "Edit project", exact: true }).click()
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("textbox", { name: en["dialog.project.edit.name"], exact: true })).toHaveValue(
-        fixture.project.name,
-      )
-      await dialog.getByRole("button", { name: en["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-    }
-    await trigger.click()
-    await menu.getByRole("menuitem", { name: fixture.project.name, exact: true }).click()
-    await expect(page).toHaveURL(new URL("/", page.url()).href)
-    const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-    await expect(projectRow).toBeVisible()
-    await expect(projectRow).toHaveAttribute("data-selected", "")
-    await expect(
-      page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-    ).toBeVisible()
-  })
-}
-
-test("path arrow has a glyph when the page has an older icon sprite", async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory: fixture.directory,
-    project: fixture.project,
-    sessions: fixture.sessions,
-    provider: fixture.provider,
-    pageMessages,
-  })
-  await installStressSessionTabs(page)
-  await page.route(
-    (url) => url.pathname === stressSessionHref(fixture.targetID),
-    async (route) => {
-      const response = await route.fetch()
-      await route.fulfill({
-        response,
-        body: (await response.text()).replace(
-          '<div id="root"',
-          '<svg id="opencode-v2-icon-sprite" width="0" height="0" aria-hidden="true"><symbol id="opencode-v2-icon-monitor" viewBox="0 0 16 16"><path d="M1 1h14v14H1z"/></symbol></svg><div id="root"',
-        ),
-      })
-    },
-  )
-  await page.goto(stressSessionHref(fixture.targetID))
-  const header = page.locator("[data-session-title]")
-  await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-  await header.getByRole("button", { name: fixture.project.name, exact: true }).click()
-  const path = page.getByRole("menu").getByRole("menuitem", { name: fixture.directory, exact: true })
-  const arrow = path.locator('[data-slot="session-project-open-icon"]')
-  await expect(arrow).toHaveCount(1)
-  await expect
-    .poll(() => arrow.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-    .toBeGreaterThan(0)
-  await expect(page.locator("#opencode-v2-icon-sprite")).toHaveCount(1)
-})

packages/app/e2e/regression/session-timeline-file-projection.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import { createTwoFilesPatch } from "diff"
 import {
   assistantMessage,
@@ -37,9 +36,7 @@ test("renders a completed single-file patch", async ({ page }) => {
         ),
       ]),
     ],
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, edit: { placement: "separate", details: "collapsed" } },
-    },
+    settings: { editToolPartsExpanded: true },
   })
 
   const wrapper = page.locator(`[data-timeline-part-id="${id}"]`)
@@ -71,9 +68,7 @@ test("keeps an expanded file diff header at the same viewport position", async (
   const before = Array.from({ length: 80 }, (_, index) => `export const value${index} = ${index}\n`).join("")
   const after = before.replaceAll(" = ", " = compute(").replaceAll("\n", ")\n")
   await setupTimeline(page, {
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, edit: { placement: "separate", details: "collapsed" } },
-    },
+    settings: { editToolPartsExpanded: true },
     messages: [
       userMessage([userText("Preceding context ".repeat(120))]),
       assistantMessage([
@@ -105,7 +100,6 @@ test("keeps an expanded file diff header at the same viewport position", async (
   const wrapper = page.locator(`[data-timeline-part-id="${id}"]`)
   const row = page.locator("[data-timeline-key]", { has: wrapper })
   const trigger = wrapper.getByRole("button")
-  await expect(trigger).toHaveAttribute("aria-expanded", "false")
   await expect
     .poll(() =>
       row.evaluate((element) => {

packages/app/e2e/regression/session-timeline-lifecycle-state.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   assistantID,
   assistantMessage,
@@ -24,23 +23,20 @@ for (const expanded of [false, true]) {
   test(`preserves shell user intent from a ${expanded ? "expanded" : "collapsed"} default`, async ({ page }) => {
     const id = `prt_shell_default_${expanded}`
     const timeline = await setupTimeline(page, {
-      messages: [userMessage(), assistantMessage([shell(id, "running", lines(3))], { completed: false })],
-      settings: {
-        timelineDetail: {
-          ...timelinePresets[2].value,
-          shell: { placement: "separate", details: expanded ? "expanded" : "collapsed" },
-        },
-      },
+      messages: [userMessage(), assistantMessage([shell(id, "completed", lines(3))])],
+      settings: { shellToolPartsExpanded: expanded },
     })
-    const trigger = page.locator(`[data-timeline-part-id="${id}"] [data-slot="collapsible-trigger"]`)
+    const trigger = expanded
+      ? page.locator(`[data-timeline-part-id="${id}"] [data-slot="collapsible-trigger"]`)
+      : page.getByRole("button", { name: "Used 1 Shell", exact: true })
     await expect(trigger).toHaveAttribute("aria-expanded", String(expanded))
     await trigger.click()
     await expect(trigger).toHaveAttribute("aria-expanded", String(!expanded))
 
-    await timeline.send(partUpdated(shell(id, "completed", lines(6))))
-    await timeline.send(partUpdated(textPart(`prt_sibling_${expanded}`, "Sibling content")))
-    await timeline.send(status("idle"))
-    await expect(page.getByText("Sibling content", { exact: true })).toBeVisible()
+    await timeline.send(partUpdated(shell(id, "completed", lines(6))), 180)
+    await timeline.send(partUpdated(textPart(`prt_sibling_${expanded}`, "Sibling content")), 180)
+    await timeline.send(status("busy"), 100)
+    await timeline.send(status("idle"), 250)
     await expect(trigger).toHaveAttribute("aria-expanded", String(!expanded))
   })
 }
@@ -50,9 +46,6 @@ test("transitions a streaming shell from writing through command execution", asy
   const command = "printf ready"
   const timeline = await setupTimeline(page, {
     messages: [userMessage(), assistantMessage([], { completed: false })],
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, shell: { placement: "separate", details: "collapsed" } },
-    },
   })
   await timeline.send(toolInputStarted({ sessionID, assistantMessageID: assistantID, id, name: "shell" }))
 
@@ -102,9 +95,7 @@ test("shimmers and expands a running shell command", async ({ page }) => {
   const command = "sleep 10 && echo done"
   await setupTimeline(page, {
     messages: [userMessage(), assistantMessage([shell(id, "running", "still running", command)], { completed: false })],
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, shell: { placement: "separate", details: "collapsed" } },
-    },
+    settings: { shellToolPartsExpanded: false },
   })
 
   const tool = page.locator(`[data-timeline-part-id="${id}"]`)
@@ -119,7 +110,7 @@ test("shimmers and expands a running shell command", async ({ page }) => {
 })
 
 for (const open of [false, true]) {
-  test(`keeps ${open ? "expanded" : "collapsed"} Separate reasoning intent through shell completion`, async ({
+  test(`keeps ${open ? "expanded" : "collapsed"} reasoning intent from Thinking through standalone shell into Used`, async ({
     page,
   }) => {
     const reasoningID = `prt_reasoning_hidden_${open}`
@@ -127,13 +118,7 @@ for (const open of [false, true]) {
     const assistant = assistantMessage([reasoningPart(reasoningID, "## Inspecting stability")], { completed: false })
     const timeline = await setupTimeline(page, {
       messages: [userMessage(), assistant],
-      settings: {
-        timelineDetail: {
-          ...timelinePresets[2].value,
-          thinking: { placement: "separate", details: "collapsed" },
-          shell: { placement: "separate", details: "collapsed" },
-        },
-      },
+      settings: { showReasoningSummaries: false },
       cpuRate: 4,
     })
     const reasoning = page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)
@@ -156,11 +141,28 @@ for (const open of [false, true]) {
     await timeline.send(partUpdated(shell(shellID, "completed", "done")))
     await timeline.send(messageUpdated(completedAssistantInfo(assistant)))
     await timeline.send(status("idle"))
-    await expect(group).toHaveCount(0)
-    await expect(thought).toHaveAttribute("aria-expanded", String(open))
+    const used = group.getByRole("button", { name: "Used 1 Shell", exact: true })
+    await expect(used).toHaveAttribute("aria-expanded", "false")
+    await used.click()
+    await expect(used).toHaveAttribute("aria-expanded", "true")
+    await expect(group.locator(`[data-timeline-part-id="${shellID}"]`)).toBeVisible()
+    await expect(group.getByRole("button", { name: "Thought", exact: true })).toHaveAttribute(
+      "aria-expanded",
+      String(open),
+    )
+    await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Shell")
     await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
+    await expect(used).toHaveAttribute("aria-expanded", "true")
     if (!open) await thought.click()
     await expect(reasoning.getByRole("heading", { name: "Inspecting stability", exact: true })).toBeVisible()
+    await used.click()
+    await expect(used).toHaveAttribute("aria-expanded", "false")
+    await used.click()
+    await expect(reasoning.getByRole("button", { name: "Thought", exact: true })).toHaveAttribute(
+      "aria-expanded",
+      "true",
+    )
+    await expect(reasoning.getByRole("heading", { name: "Inspecting stability", exact: true })).toBeVisible()
   })
 }
 
@@ -170,9 +172,6 @@ for (const transition of ["reasoning-end", "idle", "retry"] as const) {
     const text = "## Inspecting stability\n\nThe timeline is ready for the next step."
     const timeline = await setupTimeline(page, {
       messages: [userMessage(), assistantMessage([reasoningPart(id, text)], { completed: false })],
-      settings: {
-        timelineDetail: { ...timelinePresets[2].value, thinking: { placement: "separate", details: "collapsed" } },
-      },
     })
     const part = page.locator(`[data-timeline-part-id="${renderedPartID(id)}"]`)
     const trigger = part.locator('[data-slot="collapsible-trigger"]')

packages/app/e2e/regression/session-timeline-notices.spec.ts

@@ -1,6 +1,5 @@
 import { expect, test } from "@playwright/test"
 import type { SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client/promise"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   compactionDelta,
   compactionEnded,
@@ -50,9 +49,6 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
       ownerWarnings.push(message.text())
   })
   await setupTimeline(page, {
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, notices: { placement: "separate" } },
-    },
     sessionMessages: [
       user,
       { id: "msg_agent", type: "agent-switched", agent: "explore", time: { created: 2 } },
@@ -78,7 +74,7 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
 
   const notices = page.locator('[data-slot="session-timeline-notice"]')
   await expect(notices).toHaveCount(4)
-  await expect(notices.nth(0)).toHaveText(/^Agent changed\s*Explore$/)
+  await expect(notices.nth(0)).toContainText("Agent · explore")
   await expect(notices.nth(1)).toContainText("explore finished · Search code")
   await expect(notices.nth(2)).toContainText("Continuing after restart")
   await expect(notices.nth(3)).toContainText("Skill · Review")
@@ -88,12 +84,7 @@ test("renders current protocol notices in CLI order", async ({ page }) => {
 })
 
 test("renders a compaction summary while it streams and after completion", async ({ page }) => {
-  const timeline = await setupTimeline(page, {
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, notices: { placement: "separate" } },
-    },
-    sessionMessages: [user, assistant(true)],
-  })
+  const timeline = await setupTimeline(page, { sessionMessages: [user, assistant(true)] })
 
   await timeline.send(
     compactionStarted({
@@ -170,27 +161,27 @@ test("updates running compactions to failed and cancelled boundaries", async ({
 })
 
 test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
-  await setupTimeline(page, {
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, subagents: { placement: "separate" } },
-    },
-    sessionMessages: [user, assistant(false, true)],
-  })
+  await setupTimeline(page, { sessionMessages: [user, assistant(false, true)] })
   const card = page.locator('[data-component="task-tool-card"]')
   await expect(card).toBeVisible()
   await expect(card).toContainText("Inspect code")
   await expect(card).not.toContainText("(background)")
   await expect(page.getByText("Called `subagent`", { exact: false })).toHaveCount(0)
   await expect(page.locator('[data-component="background-tool-control"]')).toHaveCount(0)
-  const hint = page.getByRole("button", { name: /move running work to the background/i })
+  const hint = page.locator('[data-component="session-background-hint"]')
+  const hintPrefix = hint.locator('[data-slot="session-background-hint-prefix"]')
   await expect(hint).toBeVisible()
   await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
   await expect
     .poll(async () => {
-      const [cardBox, hintBox] = await Promise.all([card.boundingBox(), hint.boundingBox()])
-      if (!cardBox || !hintBox) return undefined
+      const [cardBox, hintBox, prefixBox] = await Promise.all([
+        card.boundingBox(),
+        hint.boundingBox(),
+        hintPrefix.boundingBox(),
+      ])
+      if (!cardBox || !hintBox || !prefixBox) return undefined
       return {
-        aligned: Math.abs(cardBox.x - hintBox.x) < 2,
+        aligned: Math.abs(cardBox.x - prefixBox.x) < 2,
         ordered: cardBox.y < hintBox.y,
       }
     })
@@ -207,25 +198,21 @@ test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
 test("navigates from a running subagent card and hides background controls in the child", async ({ page }) => {
   const childID = "ses_running_child"
   await setupTimeline(page, {
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, subagents: { placement: "separate" } },
-    },
     sessionMessages: [user, assistant(false, true, childID)],
     sessions: [session(), session({ id: childID, parentID: sessionID, title: "Sleep for 5 minutes" })],
     sessionStatus: { [sessionID]: { type: "busy" }, [childID]: { type: "busy" } },
   })
 
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
+  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
   await page.locator('[data-component="task-tool-card"]').click()
   await expect(page).toHaveURL(new RegExp(`/session/${childID}$`))
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toHaveCount(0)
+  await expect(page.getByText(/move running work to the background/i)).toHaveCount(0)
 })
 
 for (const name of ["shell", "subagent"] as const) {
   test(`keeps the background shortcut available for a grouped running ${name}`, async ({ page }) => {
     const message = assistant(false, true)
     await setupTimeline(page, {
-      settings: { timelineDetail: timelinePresets[2].value },
       sessionMessages: [
         user,
         {
@@ -262,7 +249,7 @@ for (const name of ["shell", "subagent"] as const) {
     const group = page.locator('[data-timeline-part-ids="call_read,call_running"]')
     await expect(group).toBeVisible()
     await expect(group.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "false")
-    await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
+    await expect(page.locator('[data-component="session-background-hint"]')).toBeVisible()
     const request = page.waitForRequest(
       (request) =>
         request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/background`,
@@ -281,9 +268,9 @@ test("shows a badge for active background work", async ({ page }) => {
   })
 
   await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "1 background task running", exact: true })
+  const summary = page.getByRole("button", { name: "1 item running in background" })
   await expect(summary).toContainText("1")
-  await expect(summary).toContainText("1 background task running")
+  await expect(summary).toContainText("Running work in background")
   await summary.click()
   await expect(
     page.locator('[data-component="session-background-list"]').getByText("Agent", { exact: true }),
@@ -294,7 +281,6 @@ test("separates blocking and already-backgrounded work into two rows", async ({
   const backgroundID = "ses_background_existing"
   const blockingID = "ses_background_blocking"
   const timeline = await setupTimeline(page, {
-    settings: { timelineDetail: timelinePresets[2].value },
     sessionMessages: [
       user,
       {
@@ -382,22 +368,14 @@ test("separates blocking and already-backgrounded work into two rows", async ({
     },
   })
   const backgroundCard = page.locator('[data-timeline-part-id="call_backgrounded"]')
-  await expect(page.getByRole("button", { name: /move running work to the background/i })).toBeVisible()
-  const used = page
-    .locator('[data-timeline-part-ids="call_backgrounded,call_shell_backgrounded,call_blocking"]')
-    .locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-  await expect(used).toHaveText(/^Used\s*2 Agent, 1 Shell$/)
-  await expect(used).toHaveAttribute("aria-expanded", "false")
-  await used.click()
-  await expect(used).toHaveAttribute("aria-expanded", "true")
+  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
   await page.getByRole("button", { name: "Session details" }).click()
-  const summary = page.getByRole("button", { name: "2 background tasks running", exact: true })
+  const summary = page.getByRole("button", { name: "2 items running in background" })
   await expect(summary).toContainText("2")
   await summary.click()
   const list = page.locator('[data-component="session-background-list"]')
   await expect(list).toContainText("Background task")
   await expect(list).toContainText("sleep 120")
-  await expect(list).not.toContainText("Foreground task")
   await expect(backgroundCard).toContainText("Background task (background)")
   await expect(backgroundCard.locator('[data-component="session-progress-indicator-v2"]')).toBeVisible()
   await expect(

packages/app/e2e/regression/session-timeline-projection.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   assistantMessage,
   partUpdated,
@@ -15,9 +14,7 @@ test.describe("session timeline projection", () => {
     const first = "prt_patch_first"
     const second = "prt_patch_second"
     const timeline = await setupTimeline(page, {
-      settings: {
-        timelineDetail: { ...timelinePresets[2].value, edit: { placement: "separate", details: "collapsed" } },
-      },
+      settings: { editToolPartsExpanded: true },
       messages: [
         userMessage(),
         assistantMessage([
@@ -37,7 +34,6 @@ test.describe("session timeline projection", () => {
     const initial = page.locator(`[data-timeline-part-id="${first}"]`)
     const initialFile = initial.locator('[data-scope="apply-patch"] [data-type="update"]')
     await expect(initialFile).toBeVisible()
-    await expect(initialFile.getByRole("button")).toHaveAttribute("aria-expanded", "false")
     await initialFile.getByRole("button").click()
     await expect(initialFile.getByRole("button")).toHaveAttribute("aria-expanded", "true")
     await initial.evaluate((element) => {
@@ -114,11 +110,8 @@ test.describe("session timeline projection", () => {
       parentID: "msg_2000_second_user",
       created: 1700000006000,
     })
-    const timeline = await setupTimeline(page, {
-      settings: { timelineDetail: timelinePresets[2].value },
-      messages: [firstUser, aborted, failed, nextUser, nextAssistant],
-    })
-    await timeline.send(status("idle"))
+    const timeline = await setupTimeline(page, { messages: [firstUser, aborted, failed, nextUser, nextAssistant] })
+    await timeline.send(status("idle"), 100)
     const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
     await scroller.evaluate((element) => (element.scrollTop = 0))
 
@@ -134,7 +127,6 @@ test.describe("session timeline projection", () => {
     const longName = "Company Gateway Extra Long Context Model for Narrow Timeline Layouts"
     await setupTimeline(page, {
       viewport: { width: 420, height: 700 },
-      settings: { timelineDetail: { ...timelinePresets[2].value, notices: { placement: "separate" } } },
       sessionMessages: [
         {
           id: "msg_model_fast_nano",

packages/app/e2e/regression/session-timeline-reasoning-projection.spec.ts

@@ -5,49 +5,135 @@ import {
   reasoningPart,
   setupTimeline,
   textPart,
+  toolPart,
   userMessage,
 } from "../performance/timeline-stability/fixture"
 
-test("changes timeline presets and saves custom thinking details", async ({ page }) => {
+test("changes live reasoning through Settings and persists Hidden, Compact, and Full", async ({ page }) => {
   await setupTimeline(page, {
     messages: [
       userMessage(),
-      assistantMessage([
-        reasoningPart("prt_reasoning_settings", "## Inspecting stability\n\nThe selected mode controls these details."),
-      ]),
+      assistantMessage(
+        [
+          reasoningPart(
+            "prt_reasoning_settings",
+            "## Inspecting stability\n\nThe selected mode controls these details.",
+          ),
+        ],
+        { completed: false },
+      ),
     ],
   })
   const part = page.locator(`[data-timeline-part-id="${assistantID}:reasoning:0"]`)
-  const settings = page.getByTestId("settings-screen")
-  await page.keyboard.press("Control+,")
-  const slider = settings.getByRole("slider", { name: "Timeline detail", exact: true })
-  await expect(slider).toBeEnabled()
-  await slider.press("Home")
-  for (const [index, name] of ["Everything", "Detailed", "Compact", "Quiet", "Text only"].entries()) {
-    if (index) await slider.press("ArrowRight")
-    await expect(slider).toHaveValue(String(index))
-    await expect(slider).toHaveAttribute("aria-valuetext", name)
-  }
-  await slider.press("Home")
-  await settings.getByRole("button", { name: "Advanced", exact: true }).click()
-  await settings.getByRole("button", { name: "Thinking Placement Separate", exact: true }).click()
-  await page.getByRole("option", { name: "Grouped", exact: true }).click()
-  await settings.getByRole("button", { name: "Thinking Details Expanded", exact: true }).click()
-  await page.getByRole("option", { name: "Collapsed", exact: true }).click()
-  await expect(slider).toHaveAttribute("aria-valuetext", "Custom")
-  await expect
-    .poll(() =>
-      page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.timelineDetail?.thinking),
-    )
-    .toEqual({ placement: "grouped", details: "collapsed" })
-  await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-  await expect(settings).toBeHidden()
-  await page.getByRole("button", { name: "Used 1 Thought", exact: true }).click()
   await expect(part.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  await part.getByRole("button").click()
-  await expect(part.getByText("The selected mode controls these details.", { exact: true })).toBeVisible()
+  const settings = page.getByTestId("settings-screen")
+  const select = settings.locator('[data-action="settings-reasoning-mode"] [data-component="select-v2"]')
+  for (const label of ["Full", "Hidden", "Compact"] as const) {
+    await page.keyboard.press("Control+,")
+    await expect(settings.getByText("Model reasoning", { exact: true })).toBeVisible()
+    await expect(select).toHaveAttribute("aria-expanded", "false")
+    await select.click()
+    await expect(page.getByRole("listbox").getByRole("option")).toHaveText(["Hidden", "Compact", "Full"])
+    await page.getByRole("option", { name: label, exact: true }).click()
+    await expect(select).toHaveText(label)
+    await expect(select).toHaveAttribute("aria-expanded", "false")
+    await expect
+      .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.reasoningMode))
+      .toBe(label.toLowerCase())
+    await settings.getByRole("button", { name: "Back to app", exact: true }).click()
+    await expect(settings).toBeHidden()
+    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(label === "Hidden" ? 0 : 1)
+    await expect(part).toHaveCount(label === "Hidden" ? 0 : 1)
+    if (label === "Hidden") {
+      await expect(page.getByText("The selected mode controls these details.", { exact: true })).toBeHidden()
+      continue
+    }
+    await expect(part.getByRole("button")).toHaveAttribute("aria-expanded", String(label === "Full"))
+    if (label === "Full")
+      await expect(part.getByText("The selected mode controls these details.", { exact: true })).toBeVisible()
+    if (label === "Compact") {
+      await expect(part.getByRole("button")).toContainText("Inspecting stability")
+      await expect(part.getByText("The selected mode controls these details.", { exact: true })).toBeHidden()
+    }
+  }
+  await page.keyboard.press("Control+,")
+  await expect(select).toHaveText("Compact")
 })
 
+// The persisted boolean migrates to compact (false) or full (true).
+for (const summaries of [false, true]) {
+  for (const profile of ["none", "blank", "heading", "tool", "text"] as const) {
+    test(`projects legacy ${summaries ? "full" : "compact"} reasoning with ${profile}`, async ({ page }) => {
+      await setupTimeline(page, {
+        messages: [
+          userMessage(),
+          assistantMessage(
+            [
+              ...(profile === "none"
+                ? []
+                : [
+                    reasoningPart(
+                      `prt_reasoning_${summaries}_${profile}`,
+                      profile === "blank"
+                        ? "   "
+                        : "## Inspecting stability\n\nI will inspect the timeline before changing its state.",
+                    ),
+                  ]),
+              ...(profile === "tool"
+                ? [toolPart(`prt_reasoning_tool_${summaries}`, "skill", "running", { name: "inspect" })]
+                : []),
+              ...(profile === "text" ? [textPart(`prt_reasoning_text_${summaries}`, "The timeline is stable.")] : []),
+            ],
+            { completed: false },
+          ),
+        ],
+        settings: { showReasoningSummaries: summaries },
+      })
+      const part = page.locator(`[data-timeline-part-id="${assistantID}:reasoning:0"]`)
+      await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(
+        profile === "blank" || profile === "heading" ? 1 : 0,
+      )
+      if (profile === "none") {
+        await expect(part).toHaveCount(0)
+        return
+      }
+      if (profile === "blank") {
+        await expect(part).toContainText("Thinking")
+        await expect(part.getByRole("heading")).toHaveCount(0)
+        return
+      }
+      if (profile === "tool") {
+        const group = page.locator('[data-component="collapsed-tool-group"]')
+        const used = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
+        await expect(used).toHaveText(/^Used\s*1 Skill$/)
+        await expect(used).toHaveAttribute("aria-expanded", "false")
+        await expect(page.getByText("Inspecting stability", { exact: true })).toBeHidden()
+        await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Skill")
+        await used.click()
+        await expect(used).toHaveAttribute("aria-expanded", "true")
+        await expect(group.locator(`[data-timeline-part-id="prt_reasoning_tool_${summaries}"]`)).toBeVisible()
+        await expect(group.locator('[data-component="reasoning-part"]')).toHaveCount(1)
+      }
+      if (profile === "text") await expect(page.getByText("The timeline is stable.", { exact: true })).toBeVisible()
+      const trigger = part.locator('[data-slot="collapsible-trigger"]')
+      const body = part.getByText("I will inspect the timeline before changing its state.", { exact: true })
+      await expect(trigger).toContainText(profile === "heading" ? "Thinking" : "Thought")
+      await expect(trigger).toHaveAttribute("aria-expanded", String(summaries))
+      if (!summaries) {
+        await expect(body).toBeHidden()
+        if (profile === "heading") await expect(trigger).toContainText("Inspecting stability")
+        await trigger.click()
+        await expect(trigger).toHaveAttribute("aria-expanded", "true")
+      }
+      await expect(body).toBeVisible()
+      await trigger.click()
+      await expect(trigger).toHaveAttribute("aria-expanded", "false")
+      await expect(body).toBeHidden()
+      if (profile !== "heading") await expect(trigger).not.toContainText("Inspecting stability")
+    })
+  }
+}
+
 test("does not infer reasoning visibility from provider identity", async ({ page }) => {
   await setupTimeline(page, {
     messages: [

packages/app/e2e/regression/session-timeline-reducer-projection.spec.ts

@@ -18,10 +18,10 @@ test("reducer-hardening: converges when idle arrives before final part and messa
   const textID = "prt_event_order_text"
   const assistant = assistantMessage([textPart(textID, "Partial")], { completed: false })
   const timeline = await setupTimeline(page, { messages: [userMessage(), assistant] })
-  await timeline.send(status("busy"))
-  await timeline.send(status("idle"))
-  await timeline.send(partUpdated(textPart(textID, "Final after early idle")))
-  await timeline.send(messageUpdated(completedAssistantInfo(assistant)))
+  await timeline.send(status("busy"), 100)
+  await timeline.send(status("idle"), 100)
+  await timeline.send(partUpdated(textPart(textID, "Final after early idle")), 120)
+  await timeline.send(messageUpdated(completedAssistantInfo(assistant)), 250)
 
   await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
   await expect(page.locator(`[data-timeline-part-id="${renderedPartID(textID)}"]`)).toContainText(
@@ -161,19 +161,17 @@ test("keeps failed search calls and their error cards inside the collapsed stack
   ]
   await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })
 
-  const group = page.locator('[data-component="collapsed-tool-group"]')
+  const group = page.locator('[data-timeline-part-ids="prt_error_glob,prt_error_grep"]')
   const summary = group.getByRole("button", { name: "Used 1 Glob, 1 Grep", exact: true })
-  await expect(summary).toHaveAttribute("aria-expanded", "false")
+  await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Glob, 1 Grep")
   await summary.click()
   await expect(group.locator('[data-kind="tool-error-card"]')).toHaveCount(2)
   const glob = group.locator('[data-timeline-part-id="prt_error_glob"]')
-  await expect(glob.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  await glob.getByRole("button").click()
   await expect(glob).toContainText("Invalid tool input")
   await expect(glob.locator('[data-component="tool-error-card-icon"]')).toBeVisible()
   await expect(glob.locator('[data-component="tool-error-card-icon"] use')).toHaveAttribute(
     "href",
-    "#opencode-v2-icon-outline-hexagonal-warning",
+    "#opencode-v2-icon-circle-exclamation",
   )
   await expect
     .poll(() =>
@@ -182,7 +180,6 @@ test("keeps failed search calls and their error cards inside the collapsed stack
         .evaluate((element) => getComputedStyle(element, "::before").display),
     )
     .toBe("none")
-  await group.locator('[data-timeline-part-id="prt_error_grep"]').getByRole("button").click()
   await expect(group.locator('[data-timeline-part-id="prt_error_grep"]')).toContainText(
     "Search timed out after 30 seconds",
   )

packages/app/e2e/regression/session-timeline-shell-outline.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test, type Locator, type Page } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   assistantMessage,
   setupTimeline,
@@ -75,29 +74,21 @@ test("keeps the patch card inside a fractionally short virtual row", async ({ pa
     additions: 1,
     deletions: 1,
   }
-  await setupTimeline(page, {
+  const timeline = await setupTimeline(page, {
     messages: [
       userMessage(),
       assistantMessage([
-        toolPart(
-          patchID,
-          "patch",
-          "completed",
-          { patchText: "Update src/outline.ts" },
-          { metadata: { files: [file] } },
-        ),
+        toolPart(patchID, "patch", "completed", { patchText: "Update src/outline.ts" }, { metadata: { files: [file] } }),
       ]),
     ],
-    settings: {
-      timelineDetail: { ...timelinePresets[2].value, edit: { placement: "separate", details: "collapsed" } },
-    },
+    settings: { editToolPartsExpanded: true },
     reducedMotion: true,
   })
   const part = page.locator(`[data-timeline-part-id="${patchID}"]`)
   const card = part.locator('[data-component="accordion"][data-scope="apply-patch"]')
   const row = page.locator("[data-timeline-key]", { has: part })
   await expect(card).toBeVisible()
-  await expect(card.getByRole("button")).toHaveAttribute("aria-expanded", "false")
+  await timeline.settle()
 
   const geometry = await row.evaluate((element) => {
     const card = element.querySelector<HTMLElement>('[data-component="accordion"][data-scope="apply-patch"]')
@@ -115,6 +106,8 @@ test("keeps the patch card inside a fractionally short virtual row", async ({ pa
       cardHeight: cardRect.height,
     }
   })
+  await timeline.settle()
+
   expect(geometry.overflow).toBeCloseTo(0.49, 1)
   expect(geometry.paintOverflow).toBeLessThanOrEqual(0)
   const edges = await captureCardEdges(page, card)

packages/app/e2e/regression/session-timeline-tool-projection.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   assistantMessage,
   partUpdated,
@@ -8,11 +7,11 @@ import {
   userMessage,
 } from "../performance/timeline-stability/fixture"
 
-test("keeps shell and question failures in their Used group", async ({ page }) => {
+test("transitions shell and question through running error outcomes", async ({ page }) => {
   const shellID = "prt_transition_error_shell"
   const questionID = "prt_transition_error_question"
   const timeline = await setupTimeline(page, {
-    settings: { timelineDetail: timelinePresets[2].value },
+    settings: { shellToolPartsExpanded: true },
     messages: [
       userMessage(),
       assistantMessage(
@@ -24,46 +23,30 @@ test("keeps shell and question failures in their Used group", async ({ page }) =
       ),
     ],
   })
-  const group = page.locator('[data-component="collapsed-tool-group"]')
-  const used = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-  await used.click()
   await expect(page.locator(`[data-timeline-part-id="${questionID}"]`)).toHaveCount(0)
-  await timeline.send(partUpdated(toolPart(shellID, "shell", "running", { command: "exit 1" })))
-  await expect(page.locator(`[data-timeline-part-id="${shellID}"]`)).toContainText("exit 1")
-  await timeline.send(partUpdated(toolPart(questionID, "question", "running", questionInput())))
+  await timeline.send(partUpdated(toolPart(shellID, "shell", "running", { command: "exit 1" })), 120)
+  await timeline.send(partUpdated(toolPart(questionID, "question", "running", questionInput())), 180)
   await expect(page.locator(`[data-timeline-part-id="${questionID}"]`)).toHaveCount(0)
   await timeline.send(
-    partUpdated(
-      toolPart(
-        shellID,
-        "shell",
-        "completed",
-        { command: "exit 1" },
-        { output: "Command exited 1", metadata: { exit: 1 } },
-      ),
-    ),
+    partUpdated(toolPart(shellID, "shell", "error", { command: "exit 1" }, { error: "Command exited 1" })),
+    180,
   )
   await timeline.send(
     partUpdated(
       toolPart(questionID, "question", "error", questionInput(), { error: "The user dismissed this question" }),
     ),
+    250,
   )
 
-  await expect(group).toHaveAttribute("data-timeline-part-ids", `${shellID},${questionID}`)
-  await expect(used).toHaveAttribute("aria-expanded", "true")
-  const shell = group.locator(`[data-timeline-part-id="${shellID}"]`)
-  await expect(shell.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "false")
-  await shell.locator('[data-slot="collapsible-trigger"]').click()
-  await expect(shell).toContainText("Command exited 1")
-  const question = group.locator(`[data-timeline-part-id="${questionID}"]`)
-  await expect(question).toContainText(/dismissed/i)
+  await expect(page.locator(`[data-timeline-part-id="${shellID}"] [data-kind="tool-error-card"]`)).toBeVisible()
+  await expect(page.locator(`[data-timeline-part-id="${questionID}"]`)).toContainText(/dismissed/i)
 })
 
-test("keeps a failed patch in Used without losing the surviving file choice", async ({ page }) => {
+test("preserves surviving grouped patch state when its first patch fails", async ({ page }) => {
   const failed = "prt_grouped_patch_failed"
   const surviving = "prt_grouped_patch_surviving"
   const timeline = await setupTimeline(page, {
-    settings: { timelineDetail: timelinePresets[2].value },
+    settings: { editToolPartsExpanded: true },
     messages: [
       userMessage(),
       assistantMessage(
@@ -94,12 +77,9 @@ test("keeps a failed patch in Used without losing the surviving file choice", as
     ],
   })
 
-  const group = page.locator('[data-component="collapsed-tool-group"]')
-  const used = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-  await used.click()
+  const group = page.locator(`[data-timeline-part-ids="${failed},${surviving}"]`)
   const file = group.locator('[data-scope="apply-patch"] button')
   await expect(file).toBeVisible()
-  await expect(file).toHaveAttribute("aria-expanded", "false")
   await file.click()
   await expect(file).toHaveAttribute("aria-expanded", "true")
   await group.evaluate((element) => {
@@ -119,20 +99,23 @@ test("keeps a failed patch in Used without losing the surviving file choice", as
   const survivingRow = page.locator("[data-timeline-key]", {
     has: page.locator(`[data-timeline-part-id="${surviving}"]`),
   })
-  await expect(group).toHaveAttribute("data-timeline-part-ids", `${failed},${surviving}`)
-  await expect(used).toHaveAttribute("aria-expanded", "true")
-  await expect(failedRow).toHaveAttribute("data-timeline-key", /^assistant-part:context:/)
-  await expect(survivingRow).toHaveAttribute("data-timeline-key", /^assistant-part:context:/)
-  await group.locator(`[data-timeline-part-id="${failed}"] [data-slot="collapsible-trigger"]`).click()
+  await expect(failedRow).toHaveAttribute("data-timeline-key", /^assistant-part:part:/)
+  await expect(survivingRow).toHaveAttribute("data-timeline-key", /^assistant-part:file:/)
   await expect(failedRow.getByText("Patch failed visibly")).toBeVisible()
   await expect(survivingRow).toHaveAttribute("data-group-identity", "preserved")
   await expect(survivingRow.locator('[data-scope="apply-patch"] button')).toHaveAttribute("aria-expanded", "true")
+  await expect
+    .poll(async () => {
+      const previous = await failedRow.boundingBox()
+      const next = await survivingRow.boundingBox()
+      return previous && next ? next.y - (previous.y + previous.height) : Number.NEGATIVE_INFINITY
+    })
+    .toBeGreaterThanOrEqual(-0.5)
 })
 
 test("groups instruction files loaded by the same read", async ({ page }) => {
   const id = "prt_read_instructions"
   await setupTimeline(page, {
-    settings: { timelineDetail: { ...timelinePresets[2].value, tools: { placement: "separate" } } },
     messages: [
       userMessage(),
       assistantMessage([
@@ -165,10 +148,7 @@ test("groups only consecutive successful skill tools", async ({ page }) => {
     toolPart("prt_skill_break", "read", "completed", { path: "src/a.ts" }),
     toolPart("prt_skill_last", "skill", "completed", { id: "opencode" }),
   ]
-  await setupTimeline(page, {
-    settings: { timelineDetail: timelinePresets[2].value },
-    messages: [userMessage(), assistantMessage(parts)],
-  })
+  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })
 
   const group = page.locator(`[data-timeline-part-ids="${parts.map((part) => part.id).join(",")}"]`)
   await group.getByRole("button").click()

packages/app/e2e/regression/session-timeline-working.spec.ts

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { timelinePresets } from "@opencode-ai/session-ui/timeline/detail"
 import {
   assistantID,
   assistantMessage,
@@ -20,9 +19,6 @@ for (const width of [1400, 390]) {
       messages: [userMessage()],
       sessionStatus: { [sessionID]: { type: "busy" } },
       viewport: { width, height: 900 },
-      settings: {
-        timelineDetail: { ...timelinePresets[2].value, thinking: { placement: "separate", details: "collapsed" } },
-      },
     })
     const working = page.locator('[data-component="session-working"]')
     await expect(working).toHaveCount(1)
@@ -55,9 +51,7 @@ for (const name of ["shell", "patch", "subagent"] as const) {
   test(`hides Working during ${name} input and execution, then restores it on completion`, async ({ page }) => {
     const timeline = await setupTimeline(page, {
       messages: [userMessage(), assistantMessage([], { completed: false })],
-      settings: {
-        timelineDetail: { ...timelinePresets[0].value, shell: { placement: "separate", details: "collapsed" } },
-      },
+      settings: { editToolPartsExpanded: true },
     })
     const working = page.locator('[data-component="session-working"]')
     await expect(working).toBeVisible()
@@ -95,8 +89,13 @@ for (const name of ["shell", "patch", "subagent"] as const) {
     await expect(working).toHaveCount(0)
 
     await timeline.send(partUpdated(toolPart(id, name, "completed", input, { metadata })))
-    await expect(tool).toBeVisible()
-    await expect(page.locator('[data-component="collapsed-tool-group"]')).toHaveCount(0)
+    if (name === "shell") {
+      const group = page.locator('[data-component="collapsed-tool-group"]')
+      await expect(
+        group.getByRole("button", { name: "Used 1 Shell", exact: true, includeHidden: true }),
+      ).toHaveAttribute("aria-expanded", "false")
+      await expect(group).toBeVisible()
+    }
     await expect(working.locator('[data-component="text-shimmer"]')).toHaveAttribute("aria-label", "Working")
     await expect(working).toBeVisible()
     await expect(working.locator('[data-component="text-shimmer"]')).toHaveAttribute("data-active", "true")
@@ -134,7 +133,7 @@ for (const name of ["read", "shell", "subagent"] as const) {
     await expect(trigger).toHaveAttribute("aria-expanded", "false")
     await expect(working).toBeInViewport()
     if (name !== "read") {
-      const hint = page.getByRole("button", { name: /move running work to the background/i })
+      const hint = page.locator('[data-component="session-background-hint"]')
       await expect(hint).toBeInViewport()
       await expect(page.locator('[data-component="session-background-hint-row"]')).toHaveCSS("height", "24px")
       await page.screenshot({ path: testInfo.outputPath(`working-grouped-${name}.png`) })
@@ -260,7 +259,6 @@ for (const failed of [false, true]) {
     const editor = page.locator('[data-component="composer"]').getByRole("textbox")
     await expect(editor).toBeEditable()
     await editor.fill("Check the working indicator immediately.")
-    await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
     const requested = page.waitForRequest(
       (request) =>
         request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/prompt`,

packages/app/e2e/regression/settings-loading.spec.ts

@@ -27,63 +27,11 @@ test.beforeEach(async ({ page }) => {
     })),
     pageMessages: () => ({ items: [] }),
   })
-  await page.addInitScript((directory) => {
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({ projects: { local: [{ worktree: directory, expanded: true }] } }),
-    )
-  }, directory)
   await page.goto("/")
   await page.getByRole("button", { name: "Settings", exact: true }).click()
   await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences" })).toBeVisible()
 })
 
-test("settings has its own route and returns through app history", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  const home = page.getByRole("button", { name: "Home", exact: true })
-  await expect(page).toHaveURL("/settings")
-  await expect(home).toHaveAttribute("aria-pressed", "false")
-  await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-  await expect(page).toHaveURL("/")
-  await expect(home).toHaveAttribute("aria-pressed", "true")
-  await page.keyboard.press("Control+]")
-  await expect(page).toHaveURL("/settings")
-  await expect(settings.getByRole("tab", { name: "Preferences", exact: true })).toBeVisible()
-  await expect(home).toHaveAttribute("aria-pressed", "false")
-  await home.click()
-  await expect(page).toHaveURL("/")
-  await expect(settings).toBeHidden()
-  await expect(home).toHaveAttribute("aria-pressed", "true")
-})
-
-test("new session shortcut leaves settings and opens a new session screen", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await expect(settings).toBeFocused()
-  await page.keyboard.press("Control+t")
-
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toHaveCount(1)
-})
-
-test("recording a new session shortcut stays in settings until recording finishes", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Shortcuts", exact: true }).click()
-  const binding = settings.locator('[data-keybind-id="tab.new"]')
-  await binding.click()
-  await expect(binding).toHaveText("Press keys")
-  await page.keyboard.press("Control+t")
-
-  await expect(binding).toHaveText("Ctrl+T")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.locator("[data-titlebar-tab]")).toHaveCount(0)
-  await page.keyboard.press("Control+t")
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-})
-
 test("workspaces opens without waiting for inventory or sessions", async ({ page }) => {
   const inventory = Promise.withResolvers<void>()
   const sessions = Promise.withResolvers<void>()
@@ -139,79 +87,6 @@ test("extensions opens without waiting for MCPs", async ({ page }) => {
   await expect(settings.getByRole("switch", { name: "demo-mcp" })).toBeChecked()
 })
 
-test("about opens without waiting for contributors", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.fulfill({
-      json: [],
-      headers: {
-        "access-control-allow-origin": "*",
-        "access-control-expose-headers": "Link",
-        Link: `<${url}&page=1004>; rel="last"`,
-      },
-    })
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByText(/^Version /)).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByText(/^v\d+\./)).toHaveCount(0)
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeVisible()
-
-  await settings.getByRole("tab", { name: "Preferences", exact: true }).click()
-  await expect(settings.getByRole("tab", { name: "Preferences", exact: true })).toHaveAttribute("aria-selected", "true")
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const website = settings.getByRole("link", { name: "www.opencode.ai", exact: true })
-  await website.focus()
-  contributors.resolve()
-  await expect(settings.getByRole("link", { name: "988 others", exact: true })).toBeVisible()
-  await expect(website).toBeFocused()
-})
-
-test("about is available in the mobile settings menu", async ({ page }) => {
-  await page.route("https://api.github.com/repos/anomalyco/opencode/contributors?*", (route) => route.abort("failed"))
-  await page.setViewportSize({ width: 390, height: 844 })
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("button", { name: "Preferences", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("button", { name: "About", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await settings.getByRole("button", { name: "About", exact: true }).click()
-  await expect(page.getByRole("menuitemradio", { name: "About", exact: true })).toBeChecked()
-})
-
-test("about keeps its fallback when the contributor request fails", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.abort("failed")
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const failed = page.waitForEvent("requestfailed", (request) => request.url() === url)
-  contributors.resolve()
-  await failed
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-})
-
 test("workspace inventory uses the settings panel scroll area", async ({ page }) => {
   const settings = page.getByTestId("settings-screen")
   await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()

packages/app/e2e/regression/settings-padding.spec.ts

@@ -1,95 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "/tmp/settings-padding"
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_settings_padding",
-      canonical: directory,
-      name: "Settings padding",
-      vcs: "git",
-      time: { created: 1700000000000, updated: 1700000000000 },
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.route("https://api.github.com/repos/anomalyco/opencode/contributors?*", (route) =>
-    route.fulfill({ json: [] }),
-  )
-  await page.goto("/")
-  await page.getByRole("button", { name: "Settings", exact: true }).click()
-  await expect(page.getByTestId("settings-screen")).toBeFocused()
-})
-
-for (const viewport of [
-  { width: 1280, height: 720, bottom: false },
-  { width: 900, height: 600, bottom: false },
-  { width: 780, height: 600, bottom: false },
-  { width: 390, height: 844, bottom: false },
-  { width: 390, height: 844, bottom: true },
-]) {
-  test.describe(`${viewport.width}px, ${viewport.bottom ? "bottom" : "top"} navigation`, () => {
-    test.use({ viewport: { width: 1280, height: 720 }, contextOptions: { reducedMotion: "reduce" } })
-
-    test("every settings page leaves room below its final content", async ({ page }) => {
-      await page.setViewportSize(viewport)
-      const settings = page.getByTestId("settings-screen")
-      const panel = settings.locator(":scope > .settings > .settings-panel:visible")
-      if (viewport.bottom) {
-        const toggle = settings.locator('[data-action="settings-mobile-titlebar-bottom"]')
-        await toggle.locator('[data-slot="switch-control"]').click()
-        await expect(toggle.getByRole("switch")).toBeChecked()
-      }
-      let current = "Preferences"
-      for (const name of [
-        "Preferences",
-        "Appearance",
-        "Notifications",
-        "Shortcuts",
-        "Servers",
-        "Projects",
-        "Worktrees",
-        "Providers",
-        "Models",
-        "Extensions",
-        "Experimental",
-        "About",
-      ]) {
-        if (viewport.width >= 816) await settings.getByRole("tab", { name, exact: true }).click()
-        if (viewport.width < 816) {
-          await settings.getByRole("button", { name: current, exact: true }).click()
-          await page.getByRole("menuitemradio", { name, exact: true }).click()
-        }
-        current = name
-        if (name === "About") await expect(panel.getByText("Released under the MIT License")).toBeVisible()
-        if (name !== "About") {
-          await expect(
-            panel.getByRole("heading", { name: name === "Shortcuts" ? "Keyboard shortcuts" : name, exact: true }),
-          ).toBeVisible()
-        }
-        await panel.hover()
-        await page.mouse.wheel(0, 10000)
-        await expect
-          .poll(() => panel.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
-          .toBeLessThanOrEqual(1)
-        await expect
-          .poll(
-            () =>
-              panel.evaluate((el) => {
-                const body = el.querySelector(".settings-tab-body, .settings-about-content")!
-                return el.getBoundingClientRect().bottom - body.lastElementChild!.getBoundingClientRect().bottom
-              }),
-            { message: `${name} bottom clearance` },
-          )
-          .toBeGreaterThanOrEqual(viewport.bottom ? 119.5 : 79.5)
-        await expect
-          .poll(() => page.getByRole("main").evaluate((el) => el.scrollWidth - el.clientWidth))
-          .toBeLessThanOrEqual(1)
-      }
-    })
-  })
-}

packages/app/e2e/regression/settings-scroll.spec.ts

@@ -1,69 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ contextOptions: { reducedMotion: "reduce" }, colorScheme: "dark" })
-
-for (const viewport of [
-  { width: 1280, height: 720 },
-  { width: 900, height: 600 },
-  { width: 780, height: 600 },
-  { width: 390, height: 844 },
-]) {
-  test(`preferences scroll only inside the panel at ${viewport.width}x${viewport.height}`, async ({ page }) => {
-    const directory = "/tmp/settings-scroll"
-    await mockOpenCodeServer(page, {
-      directory,
-      project: {
-        id: "proj_settings_scroll",
-        canonical: directory,
-        name: "Settings scroll",
-        vcs: "git",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-      provider: { all: [], connected: [], default: {} },
-      sessions: [],
-      pageMessages: () => ({ items: [] }),
-    })
-    await page.goto("/")
-    await page.getByRole("button", { name: "Settings", exact: true }).click()
-
-    const settings = page.getByTestId("settings-screen")
-    const panel = settings.getByRole("tabpanel")
-    const main = page.getByRole("main")
-    const slider = settings.getByRole("slider", { name: "Timeline detail", exact: true })
-    await expect(settings).toBeFocused()
-    await page.setViewportSize(viewport)
-    await expect(slider).toHaveAccessibleDescription(/Choose how much activity appears in the timeline/)
-    await expect.poll(() => main.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1)
-
-    // Wheel over the outer gutter must not move the entire settings screen.
-    await main.hover({ position: { x: 1, y: 200 } })
-    await page.mouse.wheel(0, 10000)
-    await panel.hover()
-    await page.mouse.wheel(0, 10000)
-    await expect.poll(() => panel.evaluate((el) => el.scrollTop)).toBeGreaterThan(0)
-    await expect(main).toHaveJSProperty("scrollTop", 0)
-    await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeInViewport()
-
-    await slider.scrollIntoViewIfNeeded()
-    await slider.click()
-    await page.keyboard.press("Home")
-    await expect(slider).toHaveValue("0")
-    await page.keyboard.press("ArrowRight")
-    await expect(slider).toHaveValue("1")
-    await expect(slider).toBeFocused()
-
-    await settings.getByRole("button", { name: "Advanced", exact: true }).click()
-    await expect(
-      settings.getByRole("group", { name: "Set placement and details for each activity category.", exact: true }),
-    ).toBeVisible()
-    await panel.hover()
-    await page.mouse.wheel(0, 10000)
-    await expect
-      .poll(() => panel.evaluate((el) => el.scrollHeight - el.clientHeight - el.scrollTop))
-      .toBeLessThanOrEqual(1)
-    await expect(main).toHaveJSProperty("scrollTop", 0)
-    await expect.poll(() => main.evaluate((el) => el.scrollHeight - el.clientHeight)).toBeLessThanOrEqual(1)
-    await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeInViewport()
-  })
-}

packages/app/e2e/regression/tab-navigate-mousedown.spec.ts

@@ -1,6 +1,7 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
+import pkg from "../../package.json" with { type: "json" }
 
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const sessionA = session("ses_tab_a", "Tab A session")
@@ -8,42 +9,30 @@ const sessionB = session("ses_tab_b", "Tab B session")
 const sessionC = session("ses_tab_c", "Tab C session")
 const unresolvedSessionID = "ses_tab_unresolved"
 
-test("new session tab matches neighboring session widths", async ({ page }, testInfo) => {
+test("new session tab hugs its content", async ({ page }) => {
   await mockServer(page)
   await page.addInitScript(
-    ({ server, sessionA, sessionB, directory }) => {
+    ({ server, sessionID, directory }) => {
       localStorage.setItem(
         "opencode.window.browser.dat:tabs",
         JSON.stringify([
-          { type: "session", server, sessionId: sessionA },
+          { type: "session", server, sessionId: sessionID },
           { type: "draft", server, directory, draftID: "draft_tab_width" },
-          { type: "session", server, sessionId: sessionB },
         ]),
       )
     },
-    { server, sessionA: sessionA.id, sessionB: sessionB.id, directory: sessionA.directory },
+    { server, sessionID: sessionA.id, directory: sessionA.directory },
   )
 
   const href = `/server/${base64Encode(server)}/session/${sessionA.id}`
   await page.goto(href)
 
-  const tabs = page.locator("[data-titlebar-tab-slot]")
-  await expect(tabs.locator("[data-titlebar-tab-title]")).toHaveText([sessionA.title, "Session", sessionB.title])
-  await testInfo.attach("new-session-between-tabs", {
-    body: await page.locator('[data-slot="titlebar-v2"]').screenshot(),
-    contentType: "image/png",
-  })
-  for (const width of [1280, 800]) {
-    await page.setViewportSize({ width, height: 720 })
-    await expect
-      .poll(() =>
-        tabs.evaluateAll((tabs) => {
-          const widths = tabs.map((tab) => tab.getBoundingClientRect().width)
-          return Math.max(...widths) - Math.min(...widths)
-        }),
-      )
-      .toBeLessThan(1)
-  }
+  const sessionTab = page.locator(`[data-titlebar-tab-slot]:has(a[href="${href}"])`)
+  const draftTab = page.locator('[data-titlebar-tab-slot]:has(a[href^="/new-session?draftId="])')
+  await expect(draftTab).toContainText("New session")
+  const width = (await draftTab.boundingBox())?.width ?? 0
+  expect(width).toBeGreaterThan(100)
+  expect(width).toBeLessThan((await sessionTab.boundingBox())?.width ?? 0)
 })
 
 test("pressing mouse down on a tab navigates before mouse up", async ({ page }) => {
@@ -184,9 +173,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
   await expect(tabA).toContainText(sessionA.title)
   await expect(tabB).toContainText(sessionB.title)
   await expect(tabB.locator('[data-slot="tab-project"]')).toHaveText("tab-project")
-  await expect(
-    sidebar.getByRole("button", { name: "Home", exact: true }).getByText("Home", { exact: true }),
-  ).toBeVisible()
+  await expect(sidebar.getByRole("button", { name: "Home", exact: true })).toHaveText("Home")
   await expect(sidebar.getByRole("button", { name: "New session" })).toBeVisible()
   await expect(sidebar.locator('[data-slot="vertical-tabs-footer"]')).toBeVisible()
   const status = sidebar.getByRole("button", { name: "Status", exact: true })
@@ -195,7 +182,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
     .poll(async () => {
       const bounds = await sidebar.boundingBox()
       const button = await status.boundingBox()
-      return !!bounds && !!button && button.x >= bounds.x && button.x - bounds.x <= 12
+      return !!bounds && !!button && bounds.x + bounds.width - button.x - button.width <= 12
     })
     .toBe(true)
   await expect(page.locator('[data-slot="titlebar-v2"]')).toBeHidden()
@@ -232,163 +219,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
   await expect(tabB).toBeVisible()
 })
 
-for (const direction of ["ltr", "rtl"]) {
-  test(`vertical tabs keep Settings pinned while scrolling in ${direction}`, async ({ page }, testInfo) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, sessionA, sessionB, directory }) => {
-        localStorage.setItem("settings.v3", JSON.stringify({ appearance: { tabLayout: "vertical" } }))
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify([
-            { type: "session", server, sessionId: sessionA },
-            ...Array.from({ length: 24 }, (_, index) => ({
-              type: "draft",
-              server,
-              directory,
-              draftID: `draft_scroll_${index}`,
-            })),
-            { type: "session", server, sessionId: sessionB },
-          ]),
-        )
-      },
-      { server, sessionA: sessionA.id, sessionB: sessionB.id, directory: sessionA.directory },
-    )
-    await page.goto("/")
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    const settings = sidebar.getByRole("button", { name: "Settings", exact: true })
-    const scroll = sidebar.locator('[data-slot="vertical-tabs-scroll"]')
-    const hrefB = `/server/${base64Encode(server)}/session/${sessionB.id}`
-    const tabB = sidebar.locator(`[data-titlebar-tab-link][href="${hrefB}"]`)
-    await expect(sidebar.locator("[data-titlebar-tab-slot]")).toHaveCount(26)
-    await expect(settings).toHaveText("Settings")
-    await page.evaluate((direction) => document.documentElement.setAttribute("dir", direction), direction)
-
-    for (const width of [1280, 800]) {
-      await page.setViewportSize({ width, height: 360 })
-      await expect(settings).toBeInViewport({ ratio: 1 })
-      await expect(sidebar).toHaveCSS("padding-inline-start", "10px")
-      await expect(sidebar).toHaveCSS("padding-bottom", "10px")
-      await expect(settings).toHaveCSS("margin-top", "8px")
-      await expect
-        .poll(() =>
-          sidebar.locator('[data-slot="vertical-tabs-footer"]').evaluate((element) => {
-            const content = Math.max(
-              0,
-              ...Array.from(element.children, (child) => child.getBoundingClientRect().height),
-            )
-            return element.getBoundingClientRect().height - content
-          }),
-        )
-        .toBe(0)
-      await expect(scroll).toHaveCSS("mask-image", /linear-gradient/)
-      await scroll.evaluate((element) => element.scrollTo(0, 0))
-      await expect(scroll).toHaveJSProperty("scrollTop", 0)
-      const pinned = await settings.boundingBox()
-      await scroll.hover()
-      await page.mouse.wheel(0, 200)
-      await expect.poll(() => scroll.evaluate((element) => element.scrollTop)).toBeGreaterThan(0)
-      await expect.poll(() => settings.boundingBox()).toEqual(pinned)
-      await testInfo.attach(`vertical-tabs-settings-${width}`, {
-        body: await sidebar.screenshot(),
-        contentType: "image/png",
-      })
-
-      await scroll.evaluate((element) => element.scrollTo(0, element.scrollHeight))
-      await expect(tabB).toBeInViewport({ ratio: 1 })
-      await expect
-        .poll(async () => {
-          const tab = await tabB.boundingBox()
-          const viewport = await scroll.boundingBox()
-          return !!tab && !!viewport && tab.y + tab.height <= viewport.y + viewport.height - 16
-        })
-        .toBe(true)
-      await expect.poll(() => settings.boundingBox()).toEqual(pinned)
-    }
-
-    await settings.click()
-    await expect(page.getByTestId("settings-screen")).toBeVisible()
-    await expect(settings).toHaveAttribute("aria-pressed", "true")
-    await sidebar.getByRole("button", { name: "Home", exact: true }).click()
-    await expect(page.getByTestId("settings-screen")).toBeHidden()
-    await settings.focus()
-    await settings.press("Enter")
-    await expect(page.getByTestId("settings-screen")).toBeVisible()
-  })
-}
-
-for (const profile of [
-  { locale: "en", direction: "ltr" },
-  { locale: "en", direction: "rtl" },
-  { locale: "ar", direction: "rtl" },
-]) {
-  test(`vertical shortcut hints align at the row end: ${profile.locale} ${profile.direction}`, async ({ page }) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, sessionID, locale }) => {
-        localStorage.setItem("opencode.global.dat:language", JSON.stringify({ locale }))
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({
-            appearance: { tabLayout: "vertical" },
-            keybinds: { "home.toggle": "ctrl+alt+h", "tab.new": "ctrl+shift+n" },
-          }),
-        )
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify([{ type: "session", server, sessionId: sessionID }]),
-        )
-      },
-      { server, sessionID: sessionA.id, locale: profile.locale },
-    )
-    await page.goto(`/server/${base64Encode(server)}/session/${sessionA.id}`)
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    await expect(sidebar).toHaveCSS("width", "260px")
-    await page
-      .locator("html")
-      .evaluate((element, direction) => element.setAttribute("dir", direction), profile.direction)
-    await expect(sidebar).toHaveCSS("direction", profile.direction)
-
-    for (const row of [
-      { action: "home", shortcut: "Ctrl+Alt+H" },
-      { action: "new-session", shortcut: "Ctrl+Shift+N" },
-    ]) {
-      const button = sidebar.locator(`[data-action="vertical-tabs-${row.action}"]`)
-      const hint = button.locator('span[aria-hidden="true"]')
-      await expect(hint).toHaveText(row.shortcut)
-      await expect(hint.getByText(row.shortcut, { exact: true })).toHaveCSS("direction", "ltr")
-      await expect(hint).toHaveCSS("opacity", "0")
-      await button.hover()
-      await expect(hint).toHaveCSS("opacity", "1")
-      await expect
-        .poll(() =>
-          hint.evaluate((element) => {
-            const button = element.closest("button")!
-            const row = button.getBoundingClientRect()
-            const hint = element.getBoundingClientRect()
-            return getComputedStyle(button).direction === "rtl" ? hint.left - row.left : row.right - hint.right
-          }),
-        )
-        .toBeCloseTo(8, 1)
-      await page.getByRole("main").hover()
-      await expect(hint).toHaveCSS("opacity", "0")
-    }
-
-    const home = sidebar.locator('[data-action="vertical-tabs-home"]')
-    const newSession = sidebar.locator('[data-action="vertical-tabs-new-session"]')
-    await home.focus()
-    await page.keyboard.press("Tab")
-    await expect(newSession).toBeFocused()
-    await expect(newSession.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-    await page.keyboard.press("Shift+Tab")
-    await expect(home).toBeFocused()
-    await expect(home.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-  })
-}
-
-test("dedicated experimental settings control vertical tab details", async ({ page }) => {
+test("appearance experimental settings control vertical tab details", async ({ page }) => {
   await mockServer(page)
   await page.addInitScript(
     ({ server, sessionA }) => {
@@ -406,14 +237,11 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
 
   const settings = page.getByTestId("settings-screen")
   await expect(settings).toBeVisible()
-  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByRole("tablist").getByText(/^v\d+\./)).toHaveCount(0)
+  const version = settings.getByRole("tablist").getByText(`v${pkg.version}`, { exact: true })
+  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toBeInViewport()
+  await expect(version).toBeInViewport()
   await settings.getByRole("tab", { name: "Appearance" }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(settings.locator('[data-action="settings-tab-layout"]')).toHaveCount(0)
-  await expect(settings.getByRole("switch", { name: "Show project names", exact: true })).toHaveCount(0)
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
+  await expect(settings.getByRole("heading", { name: "Experimental" })).toBeVisible()
 
   const layout = settings.locator('[data-action="settings-tab-layout"]')
   await expect(layout).toContainText("Horizontal")
@@ -434,33 +262,27 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
   await page.setViewportSize({ width: 920, height: 720 })
   await expect(page.locator('[data-slot="vertical-tabs-sidebar"]')).toHaveCSS("width", "260px")
   await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
 
   await page.setViewportSize({ width: 800, height: 720 })
   await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
 
   await page.setViewportSize({ width: 390, height: 720 })
-  await settings.getByRole("button", { name: "Experimental", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Appearance", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(layout).toHaveCount(0)
-  await settings.getByRole("button", { name: "Appearance", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
-  await expect(layout).toContainText("Vertical")
-  await expect(projectNameSwitch).toBeChecked()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
   await settings.evaluate((element) => element.setAttribute("dir", "rtl"))
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()
 
   await page.setViewportSize({ width: 390, height: 360 })
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()
 
   // Reload the UI-selected preference without seeding settings storage.
   await page.reload()
   const href = `/server/${base64Encode(server)}/session/${sessionA.id}`
   await page.getByRole("button", { name: "Tabs", exact: true }).click()
-  await expect(page.locator('[data-slot="mobile-tabs-drawer"] [data-slot="tab-project"]')).toHaveText(["tab-project"])
+  await expect(page.locator('[data-slot="mobile-tabs-drawer"] [data-slot="tab-project"]')).toHaveText([
+    "tab-project",
+  ])
   await expect(
     page
       .locator('[data-slot="mobile-tabs-drawer"]')
@@ -478,7 +300,7 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
   ).toBeVisible()
   await expect(page.locator('[data-slot="titlebar-tabs"]')).toHaveCount(0)
   await page.keyboard.press("Control+,")
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
+  await settings.getByRole("tab", { name: "Appearance" }).click()
   await expect(layout).toContainText("Vertical")
 })
 

packages/app/e2e/regression/workspace-accent.spec.ts

@@ -78,13 +78,9 @@ for (const theme of ["light", "dark"] as const) {
         await expectToken(
           message,
           "background-color",
-          scenario.accent ? "--v2-background-bg-accent" : theme === "light" ? "--v2-blue-100" : "--v2-blue-1200",
-        )
-        await expectToken(
-          message,
-          "color",
-          scenario.accent ? "--v2-text-text-contrast" : theme === "light" ? "--v2-blue-700" : "--v2-blue-300",
+          scenario.accent ? "--v2-background-bg-accent" : "--v2-state-bg-info",
         )
+        await expectToken(message, "color", scenario.accent ? "--v2-text-text-contrast" : "--v2-text-text-accent")
       })
     }
 

packages/app/e2e/user-story/model-selection-flow.spec.ts

@@ -53,8 +53,9 @@ test("creates a session in a new project and selects its model", async ({ page }
     }),
     sessions: [],
     pageMessages: () => ({ items: [] }),
-    // Listings are requested by absolute path and returned relative to the stable Location.
-    fileList: (path) => (path === "C:/OpenCode" ? [{ path: "./", type: "directory", ignored: false }] : []),
+    fileList: (path) =>
+      path ? [] : [{ name: "NewProject", path: "NewProject", absolute: directory, type: "directory", ignored: false }],
+    findFiles: () => ["NewProject"],
   })
   await page.addInitScript(() => {
     localStorage.setItem("opencode.global.dat:server", JSON.stringify({ projects: { local: [] } }))
@@ -75,23 +76,12 @@ test("creates a session in a new project and selects its model", async ({ page }
   const addProject = page.locator('[data-action="home-add-project-row"]')
   await expectAppVisible(addProject)
   await addProject.click()
-  const picker = page.getByRole("dialog", { name: "Open project", exact: true })
-  await expect(picker.getByRole("combobox")).toHaveValue("C:\\OpenCode\\NewProject")
-  const listing = page.waitForRequest((request) => {
-    const url = new URL(request.url())
-    return url.pathname === "/api/fs/list" && url.searchParams.get("path") === "C:/OpenCode"
-  })
-  await picker.getByRole("button", { name: "Parent", exact: true }).click()
-  expect(new URL((await listing).url()).searchParams.get("location[directory]")).toBe(directory)
-  const directoryItem = picker.getByRole("treeitem", { name: "NewProject", exact: true })
+  const directoryItem = page.getByRole("treeitem", { name: "NewProject" })
   await expect(directoryItem).toBeVisible()
   await directoryItem.click()
-  await expect(directoryItem).toHaveAttribute("aria-selected", "true")
-  await expect(picker.getByText("C:\\OpenCode\\NewProject", { exact: true })).toBeVisible()
-  const selectFolder = picker.getByRole("button", { name: "Select folder", exact: true })
+  const selectFolder = page.getByRole("button", { name: "Select folder" })
   await expect(selectFolder).toBeEnabled()
   await selectFolder.click()
-  await expect(picker).toBeHidden()
 
   await page.locator('[data-action="home-new-session"]').click()
   await expectAppVisible(page.locator('[data-component="composer"]'))

packages/app/e2e/utils/command-palette.ts

@@ -1,57 +0,0 @@
-import { expect, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { mockOpenCodeServer } from "./mock-server"
-import { APP_READY_TIMEOUT } from "./waits"
-
-export const paletteSession = {
-  id: "ses_command_palette",
-  projectID: "proj_command_palette",
-  directory: "C:/OpenCode/CommandPalette",
-  title: "Palette fixture session",
-  time: { created: 1700000000000, updated: 1700000000000 },
-}
-
-export function captureConsoleWarnings(page: Page) {
-  const warnings: string[] = []
-  page.on("console", (message) => {
-    if (message.type() !== "warning" && message.type() !== "error") return
-    // This message comes from test isolation, not application code.
-    if (message.text() === "Service Worker registration blocked by Playwright") return
-    warnings.push(message.text())
-  })
-  return warnings
-}
-
-export async function openCommandPalette(page: Page, home = false) {
-  await mockOpenCodeServer(page, {
-    directory: paletteSession.directory,
-    project: {
-      id: paletteSession.projectID,
-      worktree: paletteSession.directory,
-      vcs: "git",
-      name: "command-palette",
-      time: paletteSession.time,
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [paletteSession],
-    pageMessages: () => ({ items: [] }),
-    findFiles: () => [],
-  })
-  const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-  await page.goto(home ? "/" : `/server/${base64Encode(server)}/session/${paletteSession.id}`)
-  if (home) {
-    await expect(
-      page.getByRole("region", { name: "Recent sessions" }).getByRole("button", { name: /Palette fixture session/ }),
-    ).toBeEnabled({ timeout: APP_READY_TIMEOUT })
-  }
-  if (!home) {
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable({ timeout: APP_READY_TIMEOUT })
-  }
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  const input = dialog.getByRole("textbox")
-  await expect(input).toBeFocused()
-  await expect(dialog.getByRole("option")).not.toHaveCount(0)
-  return { dialog, input }
-}

packages/app/src/composer/attachments/attachments.ts

@@ -1,4 +1,4 @@
-import { onCleanup, onMount } from "solid-js"
+import { onMount } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import type { ComposerAttachment, ComposerPrompt } from "../types"
 
@@ -78,7 +78,6 @@ export type ComposerAttachmentConfig = {
   onError: (error: unknown) => void
   readClipboardImage?: () => Promise<File | null>
   getPathForFile?: (file: File) => string
-  onDragCancel?: (callback: () => void) => () => void
   store?: (file: File) => Promise<{ id: string; url: string }>
 }
 
@@ -91,9 +90,6 @@ export function createComposerAttachments(
     setDraggingType: (type: "image" | "@mention" | null) => void
   },
 ) {
-  const clearDrag = () => {
-    input.setDraggingType(null)
-  }
   const capture = () => {
     const prompt = input.capture()
     const editor = input.editor()
@@ -182,7 +178,7 @@ export function createComposerAttachments(
   const handleDrop = async (event: DragEvent) => {
     if (input.isDialogActive()) return
     event.preventDefault()
-    clearDrag()
+    input.setDraggingType(null)
     const plainText = event.dataTransfer?.getData("text/plain")
     if (plainText?.startsWith("file:")) {
       const path = plainText.slice("file:".length)
@@ -195,8 +191,6 @@ export function createComposerAttachments(
   }
 
   onMount(() => {
-    const cancel = input.onDragCancel?.(clearDrag)
-    if (cancel) onCleanup(cancel)
     makeEventListener(document, "dragover", (event) => {
       if (input.isDialogActive()) return
       event.preventDefault()
@@ -204,10 +198,7 @@ export function createComposerAttachments(
       else if (event.dataTransfer?.types.includes("text/plain")) input.setDraggingType("@mention")
     })
     makeEventListener(document, "dragleave", (event) => {
-      if (!input.isDialogActive() && !event.relatedTarget) clearDrag()
-    })
-    makeEventListener(document, "keydown", (event) => {
-      if (event.key === "Escape") clearDrag()
+      if (!input.isDialogActive() && !event.relatedTarget) input.setDraggingType(null)
     })
     makeEventListener(document, "drop", handleDrop)
   })

packages/app/src/composer/composer.tsx

@@ -26,8 +26,7 @@ export function Composer(props: { class?: string; model: ComposerModel; borderUn
         modelControlsVisible={!props.model.model.loading}
         attachKeybind={command.keybindParts("file.attach")}
         attachShortcut={command.keybind("file.attach")}
-        alternateKeybind={[formatKeybind("mod", language.t), "↵"]}
-        exitShellKeybind={[formatKeybind("esc", language.t)]}
+        alternateKeybind={[formatKeybind("mod", language.t), formatKeybind("enter", language.t)]}
         modelControl={
           <ComposerModelControl
             loading={props.model.model.loading}

packages/app/src/composer/editor/editor.css

@@ -2,11 +2,6 @@
   content: "\200B";
 }
 
-[data-color-scheme="dark"] [data-component="composer"][data-dock-border-underlay="true"],
-[data-color-scheme="dark"] [data-component="new-session"] [data-component="composer"] {
+[data-color-scheme="dark"] [data-component="composer"][data-dock-border-underlay="true"] {
   background: var(--v2-background-bg-layer-01);
 }
-
-[data-color-scheme="dark"] [data-component="composer-suggestions"] [data-active] {
-  background: var(--v2-alpha-light-10);
-}

packages/app/src/composer/editor/editor.tsx

@@ -47,7 +47,6 @@ export type ComposerEditorProps = {
   attachKeybind?: string[]
   attachShortcut?: string
   alternateKeybind?: string[]
-  exitShellKeybind?: string[]
 }
 
 export function ComposerEditor(props: ComposerEditorProps) {
@@ -118,6 +117,7 @@ export function ComposerEditor(props: ComposerEditorProps) {
         class="group/composer relative min-h-[96px] w-full overflow-clip rounded-xl bg-v2-background-bg-base"
         classList={{
           "shadow-[var(--v2-elevation-raised)]": !props.borderUnderlay,
+          "border border-v2-icon-icon-info border-dashed": state.drag === "active",
         }}
         onSubmit={(event) => {
           event.preventDefault()
@@ -128,6 +128,12 @@ export function ComposerEditor(props: ComposerEditorProps) {
         onDragLeave={props.controller.onDragLeave}
         onDrop={props.controller.onDrop}
       >
+        <Show when={state.drag === "active"}>
+          <div class="pointer-events-none absolute inset-0 z-20 grid place-items-center rounded-xl bg-v2-background-bg-base/90 text-v2-text-text-base">
+            {i18n.t("ui.promptInput.dropFiles")}
+          </div>
+        </Show>
+
         <Show when={state.mode === "normal"}>
           <ComposerAttachments
             attachments={props.controller.attachments()}
@@ -275,24 +281,6 @@ export function ComposerEditor(props: ComposerEditorProps) {
               keybind={props.alternateKeybind ?? ["Mod", "Enter"]}
             />
           </Show>
-          <Show when={state.mode === "shell"}>
-            <Button
-              data-action="composer-exit-shell"
-              type="button"
-              variant="ghost-faint"
-              size="small"
-              class="me-3 gap-1.5 px-1.5"
-              onClick={() => {
-                props.controller.dispatch({ type: "mode.normal" })
-                props.controller.restoreFocus()
-              }}
-            >
-              {i18n.t("ui.promptInput.exitShell")}
-              <span class="hidden sm:block">
-                <Keybind keys={props.exitShellKeybind ?? ["ESC"]} variant="neutral" />
-              </span>
-            </Button>
-          </Show>
           <ComposerEditorSubmitButton
             mode={state.mode}
             stopping={view.submit.stopping()}
@@ -568,7 +556,7 @@ export function ComposerEditorAddMenu(props: {
         />
         <Menu.Portal>
           <Menu.Content
-            class="[&_[data-slot=menu-v2-item-shortcut]]:w-5 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
+            class="[&_[data-slot=menu-v2-item-shortcut]]:w-8 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
             style={{ "min-width": "180px" }}
           >
             <Menu.Item onSelect={props.onAttach} shortcut={props.attachShortcut}>
@@ -685,7 +673,6 @@ export function ComposerEditorPopover(props: {
 }) {
   return (
     <div
-      data-component="composer-suggestions"
       class="absolute inset-x-0 -top-2 z-40 flex max-h-80 -translate-y-full flex-col overflow-auto rounded-xl bg-v2-background-bg-base p-2 shadow-[var(--v2-elevation-raised)] no-scrollbar"
       onMouseDown={(event) => event.preventDefault()}
     >
@@ -714,7 +701,6 @@ export function ComposerEditorPopover(props: {
             <button
               type="button"
               data-suggestion-id={item.id}
-              data-active={props.activeID === item.id ? "" : undefined}
               class="flex w-full items-center gap-2 rounded-md px-2 py-1 text-start hover:bg-v2-overlay-simple-overlay-hover"
               classList={{ "bg-v2-overlay-simple-overlay-hover": props.activeID === item.id }}
               onPointerMove={() => props.onActiveChange(item)}
@@ -763,9 +749,9 @@ function ComposerEditorAlternateDelivery(props: { controller: ComposerEditorMode
             ref={setButton}
             data-action="composer-alternate-delivery"
             type="button"
-            variant="ghost-faint"
+            variant="ghost-muted"
             size="small"
-            class="me-3 gap-1.5 px-1.5 ![font-weight:530] duration-150 motion-reduce:animate-none"
+            class="me-3 gap-1.5 px-1.5 text-v2-text-text-muted ![font-weight:530] duration-150 motion-reduce:animate-none"
             classList={{
               "animate-in fade-in": presence.animate() && presence.show(),
               "animate-out fade-out fill-mode-forwards": presence.animate() && !presence.show(),

packages/app/src/composer/model.ts

@@ -42,14 +42,9 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
 
   const interaction = createComposerEditorState(prompt.mode.current())
   createEffect(
-    on(
-      () => (adapter.ready() ? prompt.mode.current() : undefined),
-      (mode) => {
-        if (!mode) return
-        // Project external draft changes without another mode write clearing restored retry metadata.
-        interaction[1](mode === "shell" ? { mode, popover: { type: "closed" } } : { mode })
-      },
-    ),
+    on(adapter.ready, (ready) => {
+      if (ready) interaction[1]("mode", prompt.mode.current())
+    }),
   )
   const mode = () => interaction[0].mode
   const history = createComposerHistory()
@@ -256,7 +251,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
   const submission = createComposerSubmit({
     adapter,
     mode,
-    commands: () => data.location.command.list({ directory: sdk().directory }),
     editor: () => editor,
     queueScroll: () => requestAnimationFrame(() => editor?.scrollIntoView({ block: "nearest" })),
     addToHistory: (value, mode) => controller.addHistory(value, mode),
@@ -351,7 +345,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
         }),
       readClipboardImage: platform.readClipboardImage,
       getPathForFile: platform.getPathForFile,
-      onDragCancel: platform.onDragCancel,
       store: platform.draftStore?.putBlob,
     },
     view: {

packages/app/src/composer/submit.test.ts

@@ -52,12 +52,10 @@ function submitInput(
   adapter: ActiveComposerAdapter | NewSessionComposerAdapter,
   notify = { missingSelection() {}, failed(_kind: "shell" | "command" | "prompt", _error: unknown) {} },
   mode: "normal" | "shell" = "normal",
-  commands: () => readonly { name: string }[] | undefined = () => [],
 ) {
   return createComposerSubmit({
     adapter,
     mode: () => mode,
-    commands,
     editor: () => undefined,
     queueScroll() {},
     addToHistory() {},
@@ -422,6 +420,7 @@ describe("Composer submission", () => {
       prompt: async () => undefined,
       command: async (value) => sent.resolve(value),
     })
+    target.data.location.command.list = () => [{ name: "review", description: "Review changes", template: "" }]
     const adapter: ActiveComposerAdapter = {
       kind: "active-session",
       state,
@@ -434,7 +433,7 @@ describe("Composer submission", () => {
       setEditor() {},
     }
 
-    await submitInput(adapter, undefined, "normal", () => [{ name: "review" }]).submit(new Event("submit"))
+    await submitInput(adapter).submit(new Event("submit"))
     const request = await sent.promise
 
     expect(request.files).toMatchObject([{ name: "app.ts", mention: { text: "@src/app.ts" } }])
@@ -443,51 +442,6 @@ describe("Composer submission", () => {
     expect(request.delivery).toBe("steer")
   })
 
-  test("captures commands before creating a session in a new worktree", async () => {
-    const state = createMemoryComposerState({ prompt: "/review https://github.com/example/repo/pull/1" }).capture()
-    const catalog = [{ name: "review" }]
-    const sent = Promise.withResolvers<"prompt" | "command">()
-    const requests: Parameters<ComposerSession["api"]["command"]>[0][] = []
-    const target = session({
-      calls: [],
-      prompt: async () => sent.resolve("prompt"),
-      command: async (value) => {
-        requests.push(value)
-        sent.resolve("command")
-      },
-    })
-    target.directory = "C:/new-worktree"
-    target.data.location.command.list = () => undefined
-    const adapter: NewSessionComposerAdapter = {
-      kind: "new-session",
-      state,
-      ready: () => true,
-      controls,
-      working: () => false,
-      submitted() {},
-      async start() {
-        // The destination catalog has not loaded, and the source composer is leaving.
-        catalog.splice(0)
-        return { session: target, cleanupReady: Promise.resolve() }
-      },
-    }
-
-    await submitInput(adapter, undefined, "normal", () => catalog).submit(new Event("submit"))
-
-    expect(await sent.promise).toBe("command")
-    expect(requests).toEqual([
-      {
-        sessionID: target.id,
-        command: "review",
-        text: "https://github.com/example/repo/pull/1",
-        files: [],
-        agents: [],
-        skills: [],
-        delivery: "steer",
-      },
-    ])
-  })
-
   test("does not run an empty shell command from hidden attachments", async () => {
     const state = createMemoryComposerState().capture()
     state.set([

packages/app/src/composer/submit.ts

@@ -27,7 +27,6 @@ type ComposerSubmission = {
 type ComposerSubmitInput = {
   adapter: ComposerAdapter
   mode: Accessor<"normal" | "shell">
-  commands: Accessor<readonly { name: string }[] | undefined>
   editor: () => HTMLDivElement | undefined
   queueScroll: () => void
   addToHistory: (prompt: Prompt, mode: "normal" | "shell") => void
@@ -66,8 +65,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
     if (submitting.has(input.adapter.state)) return
     submitting.add(input.adapter.state)
     const comments = input.comments.capture()
-    // Capture command intent before starting a session in a worktree whose catalog has not loaded.
-    const command = value.mode === "normal" ? findCommand(input.commands(), value.text) : undefined
 
     try {
       const started =
@@ -81,6 +78,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
       input.resetHistory()
       const restore = () => restoreSubmission(input, submission, value, comments)
 
+      const command = value.mode === "normal" ? findCommand(session, value.text) : undefined
       if (value.mode === "normal" && !command) {
         session.handoff?.set(handoffMessage(value))
         const optimisticBusy = !input.adapter.working()
@@ -279,11 +277,12 @@ async function sendShell(session: ComposerSession, value: ComposerSubmission) {
   await session.api.shell({ sessionID: session.id, id: Event.ID.create(), command: value.text })
 }
 
-function findCommand(commands: ReturnType<ComposerSubmitInput["commands"]>, text: string) {
+function findCommand(session: ComposerSession, text: string) {
   if (!text.startsWith("/")) return
   const [name, ...arguments_] = text.split(" ")
   const command = name.slice(1)
-  if (!commands?.some((item) => item.name === command)) return
+  if (!session.data.location.command.list({ directory: session.directory })?.some((item) => item.name === command))
+    return
   return { command, arguments: arguments_.join(" ") }
 }
 

packages/app/src/home/model.ts

@@ -3,8 +3,7 @@ import { type HomeProjectSelection, useLayout } from "@/shell/state/layout"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { useTabs } from "@/shell/tabs/tabs"
 import { toggleHomeProjectSelection } from "@/shell/layout/helpers"
-import { createEffect, createMemo, startTransition } from "solid-js"
-import type { SessionInfo } from "@opencode-ai/client/promise"
+import { createEffect, createMemo } from "solid-js"
 
 export function createHomeController() {
   const layout = useLayout()
@@ -46,18 +45,6 @@ export function createHomeController() {
     void tabs.newDraft({ server: ServerConnection.key(conn), directory })
   }
 
-  function openProjectSession(conn: ServerConnection.Any, directory: string, session: SessionInfo) {
-    const ctx = global.ensureServerCtx(conn)
-    void ctx.data.session.message.sync(session.id).catch(() => undefined)
-    void startTransition(() => {
-      const tab = tabs.addSessionTab({ server: ServerConnection.key(conn), sessionId: session.id })
-      tabs.select(tab)
-      ctx.data.session.remember(session)
-      ctx.projects.open(directory)
-      ctx.projects.touch(directory)
-    })
-  }
-
   return {
     selection: {
       value: selection,
@@ -118,7 +105,6 @@ export function createHomeController() {
         openProjectNewSession(conn, project.worktree)
       },
       openProjectNewSession,
-      openProjectSession,
     },
   }
 }

packages/app/src/home/projects/controller.tsx

@@ -14,7 +14,6 @@ import { Schema } from "effect"
 import { Persistence } from "@/runtime/persistence/schema"
 import type { HomeController } from "../model"
 import { useGlobal } from "@/runtime/server/runtime"
-import { SessionTransfer } from "@opencode-ai/schema/session-transfer"
 
 export const HomeServersSchema = Schema.Struct({
   collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
@@ -80,35 +79,6 @@ export function createHomeProjectsController(home: HomeController) {
       select: home.project.select,
       add: home.project.add,
       openNewSession: home.project.openProjectNewSession,
-      canImportSession: !!platform.openAttachmentPickerDialog,
-      importSession: (conn: ServerConnection.Any, project: LocalProject) => {
-        if (!platform.openAttachmentPickerDialog) return
-        void platform
-          .openAttachmentPickerDialog(
-            {
-              title: language.t("command.session.import"),
-              accept: ["application/json"],
-              extensions: ["json"],
-            },
-            async (file) => {
-              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
-                await file.text(),
-              )
-              const api = home.server.context(conn).sdk.api.session
-              const imported = await api.import({
-                ...Schema.encodeSync(SessionTransfer.Data)(data),
-                location: { directory: project.worktree },
-              } as Parameters<typeof api.import>[0])
-              home.project.openProjectSession(conn, project.worktree, imported)
-            },
-          )
-          .catch((cause: unknown) => {
-            showToast({
-              title: language.t("common.requestFailed"),
-              description: errorMessage(cause, language.t("common.requestFailed")),
-            })
-          })
-      },
       edit: (conn: ServerConnection.Any, project: LocalProject) => {
         void import("@/settings/workspaces/project-dialog").then(({ DialogEditProject }) => {
           void dialog.show(() => <DialogEditProject server={conn} project={project} />)

packages/app/src/home/projects/region.tsx

@@ -37,8 +37,6 @@ export function HomeProjects(props: {
       onSelectProject={props.projects.project.select}
       onAddProjects={props.projects.project.add}
       onOpenProjectNewSession={props.projects.project.openNewSession}
-      canImportSession={props.projects.project.canImportSession}
-      onImportSession={props.projects.project.importSession}
       onEditProject={props.projects.project.edit}
       onRevealProject={props.projects.project.reveal}
       onClearNotifications={props.projects.project.clearNotifications}