fix(tui): apply cursor config in mini

2026-08-21 17:16:14 +00:00 · 2026-08-19 21:47:19 +00:00
1072 changed files with 34968 additions and 31687 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Prompt and synthetic inbox ID reuse is now idempotent: reusing an ID within the same Session succeeds and returns the first admission, ignoring the retried payload, metadata, and delivery mode. Previously reuse with a differing payload failed with a conflict. Cross-Session and cross-type reuse still fail, and control items keep their operation-specific conflict behavior.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Apply shared Session model-request preparation to transient generation.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input. Recovery-applied moves now end with the same full wake as inbox-admitted moves, retrying any stranded inbox work at the new location. Interrupting with continue now also resumes a next-in-line control item: between-turn manual compaction and moves run under any drain scope, while queued prompts remain parked.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.
@@ -1,37 +0,0 @@
-name: deploy-posts
-
-on:
-  push:
-    branches:
-      - v2
-    paths:
-      - packages/posts/**
-      - bun.lock
-      - .github/workflows/deploy-posts.yml
-  workflow_dispatch:
-
-concurrency:
-  group: deploy-posts-${{ github.ref_name }}
-  cancel-in-progress: false
-
-permissions:
-  contents: read
-
-jobs:
-  deploy:
-    if: github.repository == 'anomalyco/opencode' && github.ref_name == 'v2'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Build
-        working-directory: packages/posts
-        run: bun run build
-
-      - name: Deploy
-        working-directory: packages/posts
-        run: bun run deploy
-        env:
-          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
@@ -176,7 +176,7 @@ const table = sqliteTable("session", {

 - Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `Session.prompt(...)` publishes `session.inbox.enqueued`, whose projection inserts one durable `session_inbox` row, before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. Delivery publishes `session.inbox.delivered`; its projection consumes the inbox row and inserts the visible message in the same transaction. `session_inbox` stores only unconsumed work.
- Reusing a Session ID adopts the existing Session. Reusing a user or synthetic inbox item ID is idempotent when Session and type match: the first admission wins and the retried payload, metadata, and delivery mode are ignored, whether the item is still pending or already delivered (reconciled from the projected message without retained enqueue history). Cross-Session or cross-type reuse fails. Control items keep their operation-specific conflict behavior.
+- Reusing a Session ID adopts the existing Session. While a user or synthetic inbox item is pending, reusing its ID reconciles only when Session, type, complete payload, metadata, and delivery match; conflicting reuse fails. Once delivered, retry reconciliation for those message-producing items uses the projected message and does not require retained enqueue history or the original delivery mode. Control items keep their operation-specific conflict behavior.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; interruption of a known but idle or locally unowned Session is a no-op, while the public API rejects an unknown Session.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8pRvkbUX2aZhFTFtFuUM6mPqZZhfC4mFd1+BXVMzEJk=",
-    "aarch64-linux": "sha256-df25TWdjjLKeLZJEfrDpgVaV8ZAZhHWPoV2IPIQ4U2w=",
-    "aarch64-darwin": "sha256-VjbOx7Zi9eTiPxqpKN3+EQWweBfJHf7y36sGSN1peg0=",
-    "x86_64-darwin": "sha256-q7nW4AR2OnepnDcPDtYECgcsXI+JRHOCWhPsAX8t7q0="
+    "x86_64-linux": "sha256-IxkSw0gK/qkMHZGVHqjwgM9BKhzbQX6hyF9SWUNtpzg=",
+    "aarch64-linux": "sha256-YVjpbil0QswVwi6NtVYFq3xCqpsfveG1chlNVCVI0MU=",
+    "aarch64-darwin": "sha256-CdL2mI84pawH2H5i9qu8A6IWbkmKOYHlJS+DI/Mafdw=",
+    "x86_64-darwin": "sha256-NtswwfU5WYv99bEmI4XeLwjhBGcS9ZMYLRo4MQRNtLo="
  }
 }
@@ -15,7 +15,6 @@
    "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
    "dev:www": "bun run --cwd packages/www dev",
    "dev:storybook": "bun --cwd packages/storybook storybook",
-    "bench:devex": "bun run --cwd packages/app test:bench:devex",
    "lint": "oxlint",
    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/util/src packages/core/src packages/server/src packages/protocol/src packages/cli/src",
    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
@@ -27,6 +26,7 @@
    "prepare": "husky",
    "random": "echo 'Random script'",
    "sso": "aws sso login --sso-session=opencode --no-browser",
+    "translate:app": "bun run script/translate-app.ts",
    "test": "echo 'do not run tests from root' && exit 1"
  },
  "workspaces": {
@@ -37,19 +37,19 @@
      "packages/slack"
    ],
    "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.110",
-      "@effect/platform-node": "4.0.0-rc.110",
-      "@effect/platform-node-shared": "4.0.0-rc.110",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.110",
+      "@effect/opentelemetry": "4.0.0-beta.107",
+      "@effect/platform-node": "4.0.0-beta.107",
+      "@effect/platform-node-shared": "4.0.0-beta.107",
+      "@effect/sql-sqlite-bun": "4.0.0-beta.107",
      "@npmcli/arborist": "9.4.0",
      "@types/bun": "1.3.13",
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.6",
-      "@opentui/keymap": "0.5.6",
-      "@opentui/solid": "0.5.6",
+      "@opentui/core": "0.5.4",
+      "@opentui/keymap": "0.5.4",
+      "@opentui/solid": "0.5.4",
      "@tanstack/solid-virtual": "3.13.32",
      "@shikijs/stream": "4.2.0",
      "@standard-schema/spec": "1.1.0",
@@ -71,7 +71,7 @@
      "dompurify": "3.3.1",
      "drizzle-kit": "1.0.0-rc.2",
      "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-rc.110",
+      "effect": "4.0.0-beta.107",
      "ai": "6.0.168",
      "cross-spawn": "7.0.6",
      "hono": "4.10.7",
@@ -309,7 +309,7 @@ Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and

 ### Package-like entrypoints

-Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers` and `body` overlays.
+Native catalog integrations load provider behavior through package-like entrypoints. These are export paths from the same `@opencode-ai/ai` npm package, not independently published packages. Each entrypoint exports the same `model(modelID, settings)` contract, and `settings` contains serializable provider configuration plus common `headers`, `body`, and `limits` overlays.

 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
@@ -317,6 +317,7 @@ import { model } from "@opencode-ai/ai/providers/openai/responses"
 const selected = model("gpt-5", {
  apiKey: process.env.OPENAI_API_KEY,
  headers: { "x-application": "opencode" },
+  limits: { context: 200_000, output: 64_000 },
 })
 ```

@@ -8,7 +8,6 @@ import { Protocol } from "../route/protocol.js"
 import {
  AIError,
  LLMEvent,
-  Message,
  mergeJsonRecords,
  Usage,
  type CacheHint,
@@ -32,19 +31,6 @@ import { ToolStream } from "./utils/tool-stream.js"
 const ADAPTER = "anthropic-messages"
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1"
 export const PATH = "/messages"
-export const DEFAULT_MAX_TOKENS = 32_000
-
-const SSE_EVENTS = new Set([
-  "message",
-  "message_start",
-  "message_delta",
-  "message_stop",
-  "content_block_start",
-  "content_block_delta",
-  "content_block_stop",
-  "error",
-])
-export const framing = Framing.sseEvents(SSE_EVENTS)

 export type ThinkingInput =
  | {
@@ -247,7 +233,7 @@ export type AnthropicMessagesBody = Schema.Schema.Type<typeof AnthropicMessagesB

 const AnthropicUsage = Schema.StructWithRest(
  Schema.Struct({
-    input_tokens: optionalNull(Schema.Number),
+    input_tokens: Schema.optional(Schema.Number),
    output_tokens: Schema.optional(Schema.Number),
    cache_creation_input_tokens: optionalNull(Schema.Number),
    cache_read_input_tokens: optionalNull(Schema.Number),
@@ -360,8 +346,6 @@ const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined): strin
  return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined
 }

-const hasText = (part: { readonly text: string }) => part.text.trim().length > 0
-
 const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSchema: JsonSchema): AnthropicTool => ({
  name: tool.name,
  description: tool.description,
@@ -377,18 +361,16 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
    tool: (name) => ({ type: "tool" as const, name }),
  })

-const scrubToolCallID = (id: string) => id.replace(/[^a-zA-Z0-9_-]/g, "_")
-
 const lowerToolCall = (part: ToolCallPart): AnthropicToolUseBlock => ({
  type: "tool_use",
-  id: scrubToolCallID(part.id),
+  id: part.id,
  name: part.name,
  input: part.input,
 })

 const lowerServerToolCall = (part: ToolCallPart): AnthropicServerToolUseBlock => ({
  type: "server_tool_use",
-  id: scrubToolCallID(part.id),
+  id: part.id,
  name: part.name,
  input: part.input,
 })
@@ -410,7 +392,7 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
  // Prefer the provider-owned replay payload; fall back to the result value for
  // histories constructed directly from provider events.
  const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value
-  return { type: wireType, tool_use_id: scrubToolCallID(part.id), content: payload } satisfies AnthropicServerToolResultBlock
+  return { type: wireType, tool_use_id: part.id, content: payload } satisfies AnthropicServerToolResultBlock
 })

 const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part: MediaPart) {
@@ -449,10 +431,7 @@ const lowerToolResultContent = Effect.fnUntraced(function* (part: ToolResultPart
  if (part.result.type !== "content") return ProviderShared.toolResultText(part)
  // Preserve the narrowed array element type when compiled through a consumer package.
  const content: ReadonlyArray<Tool.Content> = part.result.value
-  return yield* Effect.forEach(
-    content.filter((item) => item.type !== "text" || hasText(item)),
-    lowerToolResultContentItem,
-  )
+  return yield* Effect.forEach(content, lowerToolResultContentItem)
 })

 // Mid-conversation system messages became available with Opus 4.8 and version
@@ -469,8 +448,7 @@ const supportsNativeSystemUpdates = (request: LLMRequest) => {
  return match[3] !== undefined && match[3].length <= 2 && Number(match[3]) >= 8
 }

-const endsInServerToolUse = (message: LLMRequest["messages"][number] | undefined) => {
-  if (!message) return false
+const endsInServerToolUse = (message: LLMRequest["messages"][number]) => {
  const last = message.content.at(-1)
  return message.role === "assistant" && last?.type === "tool-call" && last.providerExecuted === true
 }
@@ -522,26 +500,13 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (

  for (const [index, message] of request.messages.entries()) {
    if (message.role === "system") {
-      const content = (yield* ProviderShared.systemUpdateText("Anthropic Messages", message)).filter(hasText)
-      if (content.length === 0) continue
      if (splitsLocalToolResults(request.messages, index))
        return yield* invalid("Anthropic Messages system updates cannot split a local tool call from its tool result")
-      const normalized = Message.make({
-        id: message.id,
-        role: "system",
-        content,
-        metadata: message.metadata,
-        native: message.native,
-      })
-      if (
-        supportsNativeSystemUpdates(request) &&
-        canUseNativeSystemUpdate(request.messages, index) &&
-        (messages.at(-1)?.role === "user" || endsInServerToolUse(request.messages[index - 1]))
-      ) {
-        messages.push(yield* lowerNativeSystemUpdate(normalized, breakpoints))
+      if (supportsNativeSystemUpdates(request) && canUseNativeSystemUpdate(request.messages, index)) {
+        messages.push(yield* lowerNativeSystemUpdate(message, breakpoints))
        continue
      }
-      const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", normalized)
+      const part = yield* ProviderShared.wrappedSystemUpdate("Anthropic Messages", message)
      const block = { type: "text" as const, text: part.text, cache_control: cacheControl(breakpoints, part.cache) }
      const previous = messages.at(-1)
      if (previous?.role === "user")
@@ -554,7 +519,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
      const content: AnthropicUserBlock[] = []
      for (const part of message.content) {
        if (part.type === "text") {
-          if (!hasText(part)) continue
          content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
          continue
        }
@@ -564,7 +528,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
        }
        return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"])
      }
-      if (content.length > 0) messages.push({ role: "user", content })
+      messages.push({ role: "user", content })
      continue
    }

@@ -572,7 +536,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
      const content: AnthropicAssistantBlock[] = []
      for (const part of message.content) {
        if (part.type === "text") {
-          if (!hasText(part)) continue
          content.push({ type: "text", text: part.text, cache_control: cacheControl(breakpoints, part.cache) })
          continue
        }
@@ -601,7 +564,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
          `Anthropic Messages assistant messages only support text, reasoning, and tool-call content for now`,
        )
      }
-      if (content.length > 0) messages.push({ role: "assistant", content })
+      messages.push({ role: "assistant", content })
      continue
    }

@@ -611,14 +574,13 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
        return yield* ProviderShared.unsupportedContent("Anthropic Messages", "tool", ["tool-result"])
      content.push({
        type: "tool_result",
-        tool_use_id: scrubToolCallID(part.id),
+        tool_use_id: part.id,
        content: yield* lowerToolResultContent(part),
        is_error: part.result.type === "error" ? true : undefined,
        cache_control: cacheControl(breakpoints, part.cache),
      })
    }
    const previous = messages.at(-1)
-    if (content.length === 0) continue
    if (previous?.role === "user" && previous.content.every((block) => block.type === "tool_result"))
      messages[messages.length - 1] = { role: "user", content: [...previous.content, ...content] }
    else messages.push({ role: "user", content })
@@ -662,6 +624,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
  const generation = request.generation
  const toolSchemaCompatibility = request.model.compatibility?.toolSchema
+  const outputLimit = request.model.defaults?.limits?.output ?? request.model.route.defaults.limits?.output ?? 4096
  // 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.
@@ -678,11 +641,10 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
        )
  // Anthropic rejects tool_choice when tools are absent; "none" is only meaningful with tools present.
  const toolChoice = tools === undefined || !request.toolChoice ? undefined : yield* lowerToolChoice(request.toolChoice)
-  const systemParts = request.system.filter(hasText)
  const system =
-    systemParts.length === 0
+    request.system.length === 0
      ? undefined
-      : systemParts.map((part) => ({
+      : request.system.map((part) => ({
          type: "text" as const,
          text: part.text,
          cache_control: cacheControl(breakpoints, part.cache),
@@ -701,7 +663,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
    tools,
    tool_choice: toolChoice,
    stream: true as const,
-    max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
+    max_tokens: generation?.maxTokens ?? outputLimit,
    temperature: generation?.temperature,
    top_p: generation?.topP,
    top_k: generation?.topK,
@@ -730,7 +692,7 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // expose that subset through `output_tokens_details.thinking_tokens`.
 const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
  if (!usage) return undefined
-  const nonCached = usage.input_tokens ?? undefined
+  const nonCached = usage.input_tokens
  const cacheRead = usage.cache_read_input_tokens ?? undefined
  const cacheWrite = usage.cache_creation_input_tokens ?? undefined
  const inputTokens = ProviderShared.sumTokens(nonCached, cacheRead, cacheWrite)
@@ -1077,7 +1039,7 @@ export const route = Route.make({
  protocol,
  endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
  auth: Auth.none,
-  framing,
+  framing: Framing.sse,
  headers: () => ({ "anthropic-version": "2023-06-01" }),
 })

@@ -289,9 +289,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
    if (message.role === "system") {
      const part = yield* ProviderShared.wrappedSystemUpdate("Gemini", message)
      const previous = contents.at(-1)
-      // Gemini rejects a continuation whose function-response turn carries extra
-      // parts, so an update after a tool result starts its own user turn.
-      if (previous?.role === "user" && !previous.parts.some((item) => "functionResponse" in item))
+      if (previous?.role === "user")
        contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
      else contents.push({ role: "user", parts: [{ text: part.text }] })
      continue
@@ -379,12 +377,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
        },
      })
    }
-    // Gemini requires every response to a parallel call batch in one user turn,
-    // so consecutive tool results join the open function-response turn.
-    const previous = contents.at(-1)
-    if (previous?.role === "user" && previous.parts.some((item) => "functionResponse" in item))
-      contents[contents.length - 1] = { role: "user", parts: [...previous.parts, ...parts] }
-    else contents.push({ role: "user", parts })
+    contents.push({ role: "user", parts })
  }

  return contents
@@ -22,8 +22,6 @@ export interface Options {
  readonly id: string
  readonly name: string
  readonly rotateAfterMs?: number
-  readonly enabled?: (url: string) => boolean
-  readonly url?: (url: string) => string
  readonly headers?: (headers: Headers.Headers) => Headers.Headers
  readonly driver?: (input: {
    readonly request: Readonly<Record<string, unknown>>
@@ -149,19 +147,18 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
      Effect.gen(function* () {
        const parts = yield* HttpTransport.jsonRequestParts(input)
        const headers = Headers.remove(options.headers?.(parts.headers) ?? parts.headers, "content-length")
-        const channel =
-          input.webSocket && (options.enabled?.(parts.url) ?? true)
-            ? yield* Effect.gen(function* () {
-                const create = yield* message(parts.jsonBody)
-                const base = driver(options, create.message)
-                return {
-                  url: yield* WebSocketTransport.toWebSocketUrl(options.url?.(parts.url) ?? parts.url),
-                  headers,
-                  rotateAfterMs: options.rotateAfterMs,
-                  driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
-                }
-              })
-            : undefined
+        const channel = input.webSocket
+          ? yield* Effect.gen(function* () {
+              const create = yield* message(parts.jsonBody)
+              const base = driver(options, create.message)
+              return {
+                url: yield* WebSocketTransport.toWebSocketUrl(parts.url),
+                headers,
+                rotateAfterMs: options.rotateAfterMs,
+                driver: options.driver?.({ request: create.request, message: create.message, base }) ?? base,
+              }
+            })
+          : undefined
        return {
          http: {
            request: ProviderShared.jsonPost({ url: parts.url, body: parts.bodyText, headers: parts.headers }),
@@ -93,8 +93,6 @@ export const InputItem = Schema.Union([
  Schema.Struct({ role: Schema.tag("developer"), content: 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),
@@ -103,7 +101,6 @@ export const InputItem = Schema.Union([
  OpenResponsesItemReference,
  Schema.Struct({
    type: Schema.tag("function_call"),
-    id: Schema.optionalKey(Schema.String),
    call_id: Schema.String,
    name: Schema.String,
    arguments: Schema.String,
@@ -118,8 +115,6 @@ type OpenResponsesInputItem = Schema.Schema.Type<typeof InputItem>
 type LoweredInputItem =
  | OpenResponsesInputItem
  | {
-      readonly type: "message"
-      readonly id?: string
      readonly role: "assistant"
      readonly content: ReadonlyArray<{ readonly type: "output_text"; readonly text: string }>
      readonly phase?: MessagePhase | null
@@ -133,6 +128,8 @@ type OpenResponsesReasoningInput = {
  summary: Array<{ type: "summary_text"; text: string }>
  encrypted_content?: string | null
 }
+type OpenResponsesReasoningReplay = Omit<OpenResponsesReasoningInput, "id">
+
 export const Tool = Schema.Struct({
  type: Schema.tag("function"),
  name: Schema.String,
@@ -162,14 +159,6 @@ export const coreFields = {
  tools: optionalArray(Tool),
  tool_choice: Schema.optional(ToolChoice),
  store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safety_identifier: Schema.optional(Schema.String),
-  stream_options: Schema.optional(
-    Schema.Struct({
-      include_obfuscation: Schema.optional(Schema.Boolean),
-    }),
-  ),
-  top_logprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
  truncation: Schema.optional(OpenResponsesOptions.TruncationSchema),
  service_tier: Schema.optional(OpenResponsesOptions.ServiceTierSchema),
  prompt_cache_key: Schema.optional(Schema.String),
@@ -190,8 +179,6 @@ export const coreFields = {
  parallel_tool_calls: Schema.optional(Schema.Boolean),
  temperature: Schema.optional(Schema.Number),
  top_p: Schema.optional(Schema.Number),
-  presence_penalty: Schema.optional(Schema.Number),
-  frequency_penalty: Schema.optional(Schema.Number),
 }

 const OpenResponsesBody = Schema.Struct({
@@ -301,20 +288,6 @@ export const Event = Schema.StructWithRest(
 )
 export type Event = Schema.Schema.Type<typeof Event>

-const RefusalEvent = Schema.Union([
-  Schema.Struct({
-    type: Schema.tag("response.refusal.delta"),
-    item_id: Schema.String,
-    delta: Schema.String,
-  }),
-  Schema.Struct({
-    type: Schema.tag("response.refusal.done"),
-    item_id: Schema.String,
-    refusal: Schema.String,
-  }),
-])
-const isRefusalEvent = Schema.is(RefusalEvent)
-
 export interface Extension {
  readonly id: string
  readonly name: string
@@ -380,42 +353,34 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
    tool: (toolName) => ({ type: "function" as const, name: toolName }),
  })

-const itemID = (providerMetadata: ProviderMetadata | undefined, providerMetadataKey: string) => {
-  const metadata = providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-    ? metadata.itemId
-    : undefined
-}
-
-const lowerToolCall = (part: ToolCallPart, providerMetadataKey: string): OpenResponsesInputItem => {
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  return {
-    type: "function_call",
-    ...(id ? { id } : {}),
-    call_id: part.id,
-    name: part.name,
-    arguments: ProviderShared.encodeJson(part.input),
-  }
-}
+const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
+  type: "function_call",
+  call_id: part.id,
+  name: part.name,
+  arguments: ProviderShared.encodeJson(part.input),
+})

 const lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
  const metadata = part.providerMetadata?.[providerMetadataKey]
-  const id = itemID(part.providerMetadata, providerMetadataKey)
-  if (!ProviderShared.isRecord(metadata) || !id) return undefined
+  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
+    return undefined
  const encryptedContent =
    typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
      ? metadata.reasoningEncryptedContent
      : undefined
  return {
    type: "reasoning",
-    id,
+    id: metadata.itemId,
    summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
    encrypted_content: encryptedContent,
  }
 }

 const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
-  return itemID(part.providerMetadata, providerMetadataKey)
+  const metadata = part.providerMetadata?.[providerMetadataKey]
+  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
+    ? metadata.itemId
+    : undefined
 }

 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
@@ -500,26 +465,24 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques

    if (message.role === "assistant") {
      const content: TextPart[] = []
-      const reasoningItems: Record<string, OpenResponsesReasoningInput> = {}
+      const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
      const reasoningReferences = new Set<string>()
      const hostedToolReferences = new Set<string>()
      const flushText = () => {
        if (content.length === 0) return
-        const groups = content.reduce<
-          Array<{ id: string | undefined; phase: MessagePhase | null | undefined; parts: TextPart[] }>
-        >((groups, part) => {
-          const metadata = part.providerMetadata?.[providerMetadataKey]
-          const id = itemID(part.providerMetadata, providerMetadataKey)
-          const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : 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] })
-          return groups
-        }, [])
+        const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
+          (groups, part) => {
+            const metadata = part.providerMetadata?.[providerMetadataKey]
+            const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
+            const group = groups.at(-1)
+            if (group && group.phase === phase) group.parts.push(part)
+            else groups.push({ phase, parts: [part] })
+            return groups
+          },
+          [],
+        )
        input.push(
          ...groups.map((group) => ({
-            type: "message" as const,
-            ...(group.id === undefined ? {} : { id: group.id }),
            role: "assistant" as const,
            content: group.parts.map((part) => ({ type: "output_text" as const, text: part.text })),
            ...(group.phase === undefined ? {} : { phase: group.phase }),
@@ -548,14 +511,19 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
              existing.encrypted_content = reasoning.encrypted_content
            continue
          }
-          reasoningItems[reasoning.id] = reasoning
-          input.push(reasoning)
+          const replay = {
+            type: reasoning.type,
+            summary: reasoning.summary,
+            encrypted_content: reasoning.encrypted_content,
+          }
+          reasoningItems[reasoning.id] = replay
+          input.push(replay)
          continue
        }
        if (part.type === "tool-call") {
          flushText()
          if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part, providerMetadataKey))
+          input.push(lowerToolCall(part))
          continue
        }
        if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -610,12 +578,6 @@ const lowerOptions = (request: LLMRequest) => {
  return {
    ...(options.instructions ? { instructions: options.instructions } : {}),
    ...(options.store !== undefined ? { store: options.store } : {}),
-    ...(options.metadata ? { metadata: options.metadata } : {}),
-    ...(options.safetyIdentifier ? { safety_identifier: options.safetyIdentifier } : {}),
-    ...(options.streamOptions?.includeObfuscation !== undefined
-      ? { stream_options: { include_obfuscation: options.streamOptions.includeObfuscation } }
-      : {}),
-    ...(options.topLogprobs !== undefined ? { top_logprobs: options.topLogprobs } : {}),
    ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
    ...(options.include ? { include: options.include } : {}),
    ...(options.reasoningEffort || options.reasoningSummary
@@ -665,8 +627,6 @@ export const fromRequestWithExtension = Effect.fn("OpenResponses.fromRequestWith
    max_output_tokens: generation?.maxTokens,
    temperature: generation?.temperature,
    top_p: generation?.topP,
-    presence_penalty: generation?.presencePenalty,
-    frequency_penalty: generation?.frequencyPenalty,
    ...lowerOptions(request),
  }
 })
@@ -735,7 +695,7 @@ const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepRe
  if (!event.delta) return [state, NO_EVENTS]
  const events: LLMEvent[] = []
  const phase = state.messagePhases[id]
-  const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
+  const metadata = phase === undefined ? undefined : providerMetadata(state, { phase })
  const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
  return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
@@ -964,7 +924,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
          state.lifecycle,
          events,
          item.id,
-          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
+          phase === undefined ? undefined : providerMetadata(state, { phase }),
        ),
        messageItems,
        messagePhases,
@@ -977,11 +937,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
    if (!item.id || !item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
    const tools = state.tools[item.id]
      ? state.tools
-      : ToolStream.start(state.tools, item.id, {
-          id: item.call_id,
-          name: item.name,
-          providerMetadata: providerMetadata(state, { itemId: item.id }),
-        })
+      : ToolStream.start(state.tools, item.id, { id: item.call_id, name: item.name })
    const result =
      item.arguments === undefined
        ? yield* ToolStream.finish(state.id, tools, item.id)
@@ -1032,19 +988,11 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
  return [state, NO_EVENTS] satisfies StepResult
 })

-const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (state: ParserState, event: Event) {
-  // Some compatible providers omit output_item.done even after completing the response.
-  const pending =
-    event.type === "response.completed"
-      ? yield* ToolStream.finishAll(state.id, state.tools)
-      : { tools: state.tools, events: NO_EVENTS }
-  const events: LLMEvent[] = [...pending.events]
-  const hasFunctionCall =
-    pending.events.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-    state.hasFunctionCall
+const onResponseFinish = (state: ParserState, event: Event): StepResult => {
+  const events: LLMEvent[] = []
  const lifecycle = Lifecycle.finish(state.lifecycle, events, {
    reason: {
-      normalized: mapFinishReason(event, hasFunctionCall),
+      normalized: mapFinishReason(event, state.hasFunctionCall),
      raw: event.response?.incomplete_details?.reason,
    },
    usage: mapUsage(event.response?.usage, state.providerMetadataKey),
@@ -1056,8 +1004,8 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
          })
        : undefined,
  })
-  return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
-})
+  return [{ ...state, lifecycle }, events]
+}

 // Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -1099,14 +1047,6 @@ export const step = (state: ParserState, event: Event) => {
        : onOutputTextDone(state, event, event.item_id),
    )
  }
-  if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
-    if (!isRefusalEvent(event)) return ProviderShared.eventError(state.id, `${event.type} is malformed`)
-    return Effect.succeed(
-      event.type === "response.refusal.delta"
-        ? onOutputTextDelta(state, event, event.item_id)
-        : onOutputTextDone(state, { ...event, text: event.refusal }, event.item_id),
-    )
-  }
  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(onReasoningDelta(state, event, event.item_id))
@@ -1134,7 +1074,8 @@ export const step = (state: ParserState, event: Event) => {
      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
    return onOutputItemDone(state, event)
  }
-  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
+  if (event.type === "response.completed" || event.type === "response.incomplete")
+    return Effect.succeed(onResponseFinish(state, event))
  if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
  if (event.type === "error")
    return decodeKnownErrorEvent(event).pipe(
@@ -28,7 +28,7 @@ import { ToolSchemaProjection } from "./utils/tool-schema.js"
 import { ToolStream } from "./utils/tool-stream.js"

 const ADAPTER = "openai-chat"
-const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"])
+const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/chat/completions"

@@ -194,7 +194,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 const OpenAIChatDelta = Schema.StructWithRest(
  Schema.Struct({
    content: optionalNull(Schema.String),
-    refusal: optionalNull(Schema.String),
    reasoning_content: optionalNull(Schema.String),
    reasoning: optionalNull(Schema.String),
    reasoning_text: optionalNull(Schema.String),
@@ -710,7 +709,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    const reasoning = reasoningDelta(delta, state.reasoningField)
    const hasLateContent =
      Boolean(delta?.content) ||
-      Boolean(delta?.refusal) ||
      reasoning !== undefined ||
      (Array.isArray(delta?.reasoning_details) && delta.reasoning_details.length > 0) ||
      toolDeltas.some((tool) => Boolean(tool.id) || Boolean(tool.function?.name) || Boolean(tool.function?.arguments))
@@ -730,7 +728,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    else if (
      reasoningDetailsObserved &&
      !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0)
+      (Boolean(delta?.content) || toolDeltas.length > 0)
    )
      lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
    const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
@@ -745,16 +743,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
    }

-    if (delta?.refusal) {
-      lifecycle = Lifecycle.reasoningEnd(
-        lifecycle,
-        events,
-        "reasoning-0",
-        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
-      )
-      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
-    }
-
    // Compatible providers may omit indexes. Prefer durable identity, then use
    // batch position for parallel deltas or the latest call for sparse chunks.
    for (const [position, tool] of toolDeltas.entries()) {
@@ -11,7 +11,7 @@ import { optionalArray, ProviderShared } from "./shared.js"
 import { Lifecycle } from "./utils/lifecycle.js"
 import { OpenAIImage } from "./utils/openai-image.js"
 import { ToolSchemaProjection } from "./utils/tool-schema.js"
-import { OpenResponsesChannel, type Options } from "./open-responses-channel.js"
+import { OpenResponsesChannel } from "./open-responses-channel.js"
 import { OpenAIResponsesChannel } from "./openai-responses-channel.js"

 const ADAPTER = "openai-responses"
@@ -42,8 +42,6 @@ const OpenAIResponsesToolChoice = Schema.Union([

 const OpenAIResponsesInputItem = Schema.Union([
  Schema.Struct({
-    type: Schema.tag("message"),
-    id: Schema.optionalKey(Schema.String),
    role: Schema.tag("assistant"),
    content: Schema.Array(Schema.Struct({ type: Schema.tag("output_text"), text: Schema.String })),
    phase: Schema.optionalKey(Schema.NullOr(OpenResponses.MessagePhase)),
@@ -247,16 +245,12 @@ const endpoint = Endpoint.path<OpenAIResponsesBody>(PATH, { baseURL: DEFAULT_BAS
 const auth = Auth.none

 export const httpTransport = HttpTransport.sseJson.with<OpenAIResponsesBody>()
-export const channelTransport = (options: Omit<Options, "driver">) =>
-  OpenResponsesChannel.transport<OpenAIResponsesBody>({
-    ...options,
-    driver: (input) => OpenAIResponsesChannel.driver({ id: options.id, name: options.name, ...input }),
-  })
-export const transport = channelTransport({
+export const transport = OpenResponsesChannel.transport<OpenAIResponsesBody>({
  id: ADAPTER,
  name: NAME,
  rotateAfterMs: WEBSOCKET_ROTATE_AFTER_MS,
  headers: (headers) => Headers.set(headers, "openai-beta", headers["openai-beta"] ?? WEBSOCKET_PROTOCOL_HEADER),
+  driver: (input) => OpenAIResponsesChannel.driver({ id: ADAPTER, name: NAME, ...input }),
 })

 export const route = Route.make({
@@ -197,28 +197,19 @@ export const errorText = (error: unknown) => {

 /**
 * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. The SSE channel emits a
+ * decoder, and drops empty / `[DONE]` keep-alive events so the protocol event
+ * schema sees one JSON string per element. The SSE channel emits a
 * `Retry` control event on its error channel; we drop it here (we don't
 * implement client-driven retries). Decoder failures become provider output
 * errors so the public error channel stays `AIError`.
 */
-export const sseFraming = (
-  bytes: Stream.Stream<Uint8Array, AIError>,
-  events?: ReadonlySet<string>,
-): Stream.Stream<string, AIError> =>
+export const sseFraming = (bytes: Stream.Stream<Uint8Array, AIError>): Stream.Stream<string, AIError> =>
  bytes.pipe(
    Stream.decodeText(),
    Stream.pipeThroughChannel(Sse.decode()),
    Stream.catchTag("Retry", () => Stream.empty),
    Stream.catchTag("SseError", (error) => Stream.fail(eventError("sse", error.message))),
-    Stream.filter(
-      (event) =>
-        (events === undefined || events.has(event.event)) &&
-        event.data.length > 0 &&
-        (event.data !== "[DONE]" || (events !== undefined && event.event !== "message")),
-    ),
+    Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"),
    Stream.map((event) => event.data),
  )

@@ -47,17 +47,9 @@ export const AllowedTools = Schema.Struct({
 })
 export type AllowedTools = typeof AllowedTools.Type

-export const StreamOptions = Schema.Struct({
-  includeObfuscation: Schema.optional(Schema.Boolean),
-})
-
 export const Options = Schema.Struct({
  instructions: Schema.optional(Schema.String),
  store: Schema.optional(Schema.Boolean),
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  safetyIdentifier: Schema.optional(Schema.String),
-  streamOptions: Schema.optional(StreamOptions),
-  topLogprobs: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 20 }))),
  reasoningEffort: Schema.optional(ReasoningEffort),
  reasoningSummary: Schema.optional(Schema.Literals(["auto", "concise", "detailed"])),
  include: Schema.optional(Schema.Array(ResponseIncludableSchema)),
@@ -74,7 +74,6 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
-const NETWORK_ERROR_TEXT = /network[-_\s]error/i

 export interface ProviderFailure {
  readonly message: string
@@ -128,7 +127,6 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
-  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalReason({ ...common, status: input.status })
  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
    return new ProviderInternalReason({
      ...common,
@@ -4,6 +4,11 @@ export interface Settings extends Readonly<Record<string, unknown>> {
  readonly baseURL?: string
  readonly headers?: Readonly<Record<string, string>>
  readonly body?: Readonly<Record<string, unknown>>
+  readonly limits?: {
+    readonly context: number
+    readonly input?: number
+    readonly output: number
+  }
 }

 export interface Definition<
@@ -90,6 +90,7 @@ const config = (settings: Settings): Config => {
    credentials: settings.credentials,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    region: settings.region,
  }
@@ -62,6 +62,7 @@ export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, se
    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    region: settings.region,
  }).model(modelID)
 }
@@ -68,6 +68,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -63,6 +63,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
 }
@@ -1,4 +1,3 @@
-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 as RouteDef, RouteDefaultsInput } from "../route/client.js"
@@ -11,7 +10,6 @@ import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-opt

 export const id = ProviderID.make("azure")
 const routeAuth = Auth.remove("authorization")
-const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 55 * 60 * 1000

 // Azure needs the customer's resource URL; supply either `resourceName`
 // (helper builds the URL) or `baseURL` directly.
@@ -42,30 +40,6 @@ const responsesRoute = OpenAIResponses.route.with({
  id: "azure-openai-responses",
  provider: id,
  auth: routeAuth,
-  transport: OpenAIResponses.channelTransport({
-    id: "azure-openai-responses",
-    name: "Azure OpenAI Responses",
-    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-    enabled: (value) => {
-      const url = new URL(value)
-      return (
-        url.protocol === "https:" &&
-        url.hostname.endsWith(".openai.azure.com") &&
-        url.pathname.endsWith("/openai/v1/responses") &&
-        url.searchParams.get("api-version") === "v1"
-      )
-    },
-    url: (value) => {
-      const url = new URL(value)
-      url.searchParams.delete("api-version")
-      return url.toString()
-    },
-    headers: (headers) => {
-      const apiKey = headers["api-key"]
-      if (!apiKey) return headers
-      return Headers.remove(Headers.set(headers, "authorization", `Bearer ${apiKey}`), "api-key")
-    },
-  }),
 })

 const chatRoute = OpenAIChat.route.with({
@@ -152,6 +126,7 @@ const config = (settings: Settings): Config => {
    apiVersion: settings.apiVersion,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
    useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
@@ -75,6 +75,7 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -4,6 +4,7 @@ import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { GoogleVertexShared } from "./google-vertex-shared.js"
@@ -13,7 +14,6 @@ export type AnthropicProviderOptionsInput = AnthropicMessages.ProviderOptionsInp
 export type AnthropicThinkingInput = AnthropicMessages.ThinkingInput

 const VERSION = "vertex-2023-10-16" as const
-const HEADER_VERSION = "2023-06-01" as const

 export const id = ProviderID.make("google-vertex")

@@ -57,8 +57,7 @@ const route = Route.make({
  }),
  endpoint: Endpoint.path(({ request }) => `/${request.model.id}:streamRawPredict`),
  auth: Auth.none,
-  framing: AnthropicMessages.framing,
-  headers: () => ({ "anthropic-version": HEADER_VERSION }),
+  framing: Framing.sse,
 })

 export const routes = [route]
@@ -111,6 +110,7 @@ export const model: ProviderPackage.Definition<Settings, AnthropicMessages.Provi
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -80,6 +80,7 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -119,6 +119,7 @@ export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    location: settings.location,
    project: settings.project,
    providerOptions: settings.providerOptions,
@@ -63,6 +63,7 @@ export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsI
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)

@@ -55,6 +55,7 @@ export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOp
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -74,6 +74,7 @@ export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsIn
    baseURL: settings.baseURL,
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    provider: settings.provider,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -124,6 +124,7 @@ const config = (settings: Settings): Config => {
    baseURL: settings.baseURL,
    headers: Object.keys(headers).length === 0 ? undefined : headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
    queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
  }
@@ -200,5 +200,6 @@ export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptio
    baseURL: settings.baseURL,
    headers: settings.headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
@@ -28,19 +28,13 @@ export interface Settings extends ProviderPackage.Settings {

 export type { XAIImageOptions } from "../protocols/xai-images.js"

-const RESPONSES_WEBSOCKET_ROTATE_AFTER_MS = 24 * 60 * 1000
-
 const responsesRoute = Route.make({
  id: "openai-responses",
  provider: id,
  providerMetadataKey: "xai",
  protocol: OpenAIResponses.protocol,
  endpoint: Endpoint.path("/responses", { baseURL: OpenAICompatibleProfiles.profiles.xai.baseURL }),
-  transport: OpenAIResponses.channelTransport({
-    id: "openai-responses",
-    name: "xAI Responses",
-    rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
-  }),
+  transport: OpenAIResponses.httpTransport,
  defaults: { providerOptions: { store: false } },
 })

@@ -107,6 +101,7 @@ export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput
    baseURL: settings.baseURL,
    headers: settings.headers,
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    limits: settings.limits,
    providerOptions: settings.providerOptions,
  }).model(modelID)
 export const responses = provider.responses
@@ -16,6 +16,7 @@ import {
  LLMRequest,
  LLMResponse,
  LanguageModel,
+  LanguageModelLimits,
  LLMEvent,
  InvalidProviderOutputReason,
  ProviderID,
@@ -73,6 +74,7 @@ export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">

 export interface RouteDefaults {
  readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits
  readonly generation?: GenerationOptions
  readonly providerOptions?: ProviderOptions
  readonly http?: HttpOptions
@@ -80,6 +82,7 @@ export interface RouteDefaults {

 export interface RouteDefaultsInput {
  readonly headers?: Record<string, string>
+  readonly limits?: LanguageModelLimits.Input
  readonly generation?: GenerationOptions.Input
  readonly providerOptions?: ProviderOptions
  readonly http?: HttpOptions.Input
@@ -116,6 +119,7 @@ const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefault
    ...base,
    ...patch,
    headers,
+    limits: patch.limits === undefined ? base?.limits : LanguageModelLimits.make(patch.limits),
    generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
    http: mergeHttpOptions(
@@ -24,10 +24,4 @@ export interface Definition<Frame> {
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse: Definition<string> = { id: "sse", frame: ProviderShared.sseFraming }

-/** SSE framing restricted to protocol-recognized event names. */
-export const sseEvents = (events: ReadonlySet<string>): Definition<string> => ({
-  id: "sse",
-  frame: (bytes) => ProviderShared.sseFraming(bytes, events),
-})
-
 export * as Framing from "./framing.js"
@@ -114,7 +114,22 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
  return Object.values(result).some((value) => value !== undefined) ? result : undefined
 }

+export class LanguageModelLimits extends Schema.Class<LanguageModelLimits>("LLM.LanguageModelLimits")({
+  context: Schema.optional(Schema.Number),
+  input: Schema.optional(Schema.Number),
+  output: Schema.optional(Schema.Number),
+}) {}
+
+export namespace LanguageModelLimits {
+  export type Input = LanguageModelLimits | ConstructorParameters<typeof LanguageModelLimits>[0]
+
+  /** Normalize model limit input into the canonical `LanguageModelLimits` class. */
+  export const make = (input: Input | undefined) =>
+    input instanceof LanguageModelLimits ? input : new LanguageModelLimits(input ?? {})
+}
+
 export class LanguageModelDefaults extends Schema.Class<LanguageModelDefaults>("LLM.LanguageModelDefaults")({
+  limits: Schema.optional(LanguageModelLimits),
  generation: Schema.optional(GenerationOptions),
  providerOptions: Schema.optional(ProviderOptions),
  http: Schema.optional(HttpOptions),
@@ -124,6 +139,7 @@ export namespace LanguageModelDefaults {
  export type Input =
    | LanguageModelDefaults
    | {
+        readonly limits?: LanguageModelLimits.Input
        readonly generation?: GenerationOptions.Input
        readonly providerOptions?: ProviderOptions
        readonly http?: HttpOptions.Input
@@ -133,6 +149,7 @@ export namespace LanguageModelDefaults {
  export const make = (input: Input) => {
    if (input instanceof LanguageModelDefaults) return input
    return new LanguageModelDefaults({
+      limits: input.limits === undefined ? undefined : LanguageModelLimits.make(input.limits),
      generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
      providerOptions: input.providerOptions,
      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
@@ -270,20 +270,21 @@ describe("request option precedence", () => {
    ),
  )

-  it.effect("uses the Anthropic default before call maxTokens", () =>
+  it.effect("uses model output limits after route limits and before call maxTokens", () =>
    Effect.gen(function* () {
      const route = AnthropicMessages.route.with({
        endpoint: { baseURL: "https://api.anthropic.test/v1/" },
        auth: Auth.header("x-api-key", "test"),
+        limits: { output: 128 },
      })
-      const model = route.model({ id: "claude-sonnet-4-5" })
+      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
      const withoutMaxTokens = yield* compileRequest(LLM.request({ model, prompt: "Say hello.", cache: "none" }))
      const withMaxTokens = yield* compileRequest(
-        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 8_000 } }),
+        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 32 } }),
      )

-      expect(withoutMaxTokens.body.max_tokens).toBe(32_000)
-      expect(withMaxTokens.body.max_tokens).toBe(8_000)
+      expect(withoutMaxTokens.body.max_tokens).toBe(64)
+      expect(withMaxTokens.body.max_tokens).toBe(32)
    }),
  )
 })
@@ -1,100 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "tool",
-      "continuation"
-    ],
-    "name": "openai-responses-websocket/continues-a-tool-call-over-one-socket",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Call get_weather once, then reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.function_call_arguments.delta\",\"item_id\":\"fc_ws_weather\",\"delta\":\"{\\\"city\\\":\\\"Paris\\\"}\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"function_call_output\",\"call_id\":\"call_ws_weather\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"previous_response_id\":\"resp_ws_tool_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_tool_2\",\"delta\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_tool_2\",\"text\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Paris is sunny.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -1,119 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "reconnect",
-      "full-context"
-    ],
-    "name": "openai-responses-websocket/reconstructs-full-context-after-reconnect",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_1\",\"delta\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_1\",\"text\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Beta.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_2\",\"delta\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_2\",\"text\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Beta.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -1,129 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "continuation",
-      "recovery"
-    ],
-    "name": "openai-responses-websocket/recovers-from-explicit-continuation-rejection",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_1\",\"delta\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_1\",\"text\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"previous_response_id\":\"resp_ws_rejection_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"error\",\"error\":{\"code\":\"previous_response_not_found\",\"message\":\"Previous response not found\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_2\",\"delta\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_2\",\"text\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Recovered.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -10,9 +10,6 @@ export const sseEvents = (...chunks: ReadonlyArray<unknown>): string =>

 const formatChunk = (chunk: unknown) => `data: ${typeof chunk === "string" ? chunk : JSON.stringify(chunk)}\n\n`

-export const sseNamedEvent = (event: string, data: unknown): string =>
-  `event: ${event}\ndata: ${typeof data === "string" ? data : JSON.stringify(data)}`
-
 /**
 * Build an SSE body from already-serialized strings (used when the chunk shape
 * itself is part of what's being tested, e.g. malformed chunks).
@@ -121,6 +121,7 @@ describe("llm constructors", () => {
    const model = chatRoute.model({
      id: "kimi-k2",
      defaults: {
+        limits: { context: 128_000, output: 8_192 },
        generation: { maxTokens: 1_024, stop: ["END"] },
        providerOptions: { parallelToolCalls: false },
        http: { body: { extra_body: true } },
@@ -129,6 +130,7 @@ describe("llm constructors", () => {
    })
    const request = LLM.request({ model, prompt: "Say hello." })

+    expect(request.model.defaults?.limits).toEqual({ context: 128_000, output: 8_192 })
    expect(request.model.defaults?.generation).toEqual({ maxTokens: 1_024, stop: ["END"] })
    expect(request.model.defaults?.providerOptions).toEqual({ parallelToolCalls: false })
    expect(request.model.defaults?.http).toEqual({ body: { extra_body: true } })
@@ -82,14 +82,6 @@ describe("provider error classification", () => {
    ])
  })

-  test("classifies network error text as provider internal", () => {
-    expect(
-      ["network error", "network-error", "network_error"].map(
-        (message) => classifyProviderFailure({ message })._tag,
-      ),
-    ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
-  })
-
  test("classifies nested provider codes when a top-level code is also present", () => {
    expect(
      [
@@ -43,6 +43,7 @@ describe("provider package entrypoints", () => {
      baseURL: "https://provider.example.test/v1",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
    }
    const openrouter = OpenRouter.model("anthropic/claude-sonnet-4", {
      ...settings,
@@ -57,6 +58,7 @@ describe("provider package entrypoints", () => {
      expect(selected.route.endpoint.baseURL).toBe(settings.baseURL)
      expect(selected.route.defaults.headers).toEqual(settings.headers)
      expect(selected.route.defaults.http?.body).toEqual(settings.body)
+      expect(selected.route.defaults.limits).toEqual(settings.limits)
    }
    expect(openrouter.route.defaults.providerOptions).toEqual({ usage: true })
    expect(xai.route.defaults.providerOptions).toMatchObject({ reasoningEffort: "high", store: false })
@@ -68,12 +70,14 @@ describe("provider package entrypoints", () => {
      baseURL: "https://api.openai.test/v1",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
      unrelatedInheritedSetting: true,
    })

    expect(selected.route.id).toBe("openai-responses")
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
  })

  test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
@@ -84,6 +88,7 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
      providerOptions: { reasoningEffort: "low", store: true },
    })

@@ -95,6 +100,7 @@ describe("provider package entrypoints", () => {
    })
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "low", store: true })
  })

@@ -106,6 +112,7 @@ describe("provider package entrypoints", () => {
      provider: "example",
      headers: { "x-application": "opencode" },
      body: { metadata: { user_id: "user_1" } },
+      limits: { context: 200_000, output: 64_000 },
      providerOptions: { effort: "low" },
    })

@@ -117,6 +124,7 @@ describe("provider package entrypoints", () => {
    })
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ metadata: { user_id: "user_1" } })
+    expect(selected.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(selected.route.defaults.providerOptions).toEqual({ effort: "low" })
  })

@@ -177,6 +185,7 @@ describe("provider package entrypoints", () => {
      resourceName: "opencode-test",
      headers: { "x-application": "opencode" },
      body: { service_tier: "priority" },
+      limits: { context: 200_000, output: 64_000 },
    }

    const responses = AzureResponses.model("deployment", settings)
@@ -187,6 +196,7 @@ describe("provider package entrypoints", () => {
    expect(responses.route.endpoint.baseURL).toBe("https://opencode-test.openai.azure.com/openai/v1")
    expect(responses.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(responses.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+    expect(responses.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
    expect(chat.route.id).toBe("azure-openai-chat")
  })

@@ -218,6 +228,7 @@ describe("provider package entrypoints", () => {
      baseURL: "https://generativelanguage.test/v1beta",
      headers: { "x-application": "opencode" },
      body: { safetySettings: [] },
+      limits: { context: 1_000_000, output: 65_536 },
      providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
    })

@@ -225,6 +236,7 @@ describe("provider package entrypoints", () => {
    expect(selected.route.endpoint.baseURL).toBe("https://generativelanguage.test/v1beta")
    expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(selected.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(selected.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
    expect(selected.route.defaults.providerOptions).toEqual({ thinkingConfig: { thinkingBudget: 1_024 } })
  })

@@ -238,6 +250,7 @@ describe("provider package entrypoints", () => {
      apiKey: "fixture",
      headers: { "x-application": "opencode" },
      body: { safetySettings: [] },
+      limits: { context: 1_000_000, output: 65_536 },
    })
    const messages = GoogleVertexMessages.model("claude-sonnet-4-6", {
      accessToken: "fixture",
@@ -261,6 +274,7 @@ describe("provider package entrypoints", () => {
    expect(gemini.route.endpoint.baseURL).toBe("https://aiplatform.googleapis.com/v1/publishers/google")
    expect(gemini.route.defaults.headers).toEqual({ "x-application": "opencode" })
    expect(gemini.route.defaults.http?.body).toEqual({ safetySettings: [] })
+    expect(gemini.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
    expect(
      GoogleVertex.model("gemini-3.5-flash", {
        accessToken: "fixture",
@@ -8,7 +8,7 @@ import * as AnthropicMessages from "../../src/protocols/anthropic-messages.js"
 import { continuationRequest, nativeAnthropicMessagesContinuation } from "../continuation-scenarios.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse, fixedResponse } from "../lib/http.js"
-import { sseEvents, sseNamedEvent, sseRaw } from "../lib/sse.js"
+import { sseEvents } from "../lib/sse.js"

 const model = AnthropicMessages.route
  .with({ endpoint: { baseURL: "https://api.anthropic.test/v1/" }, auth: Auth.header("x-api-key", "test") })
@@ -58,93 +58,6 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("filters empty text blocks while preserving assistant replay state", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          system: [
-            { type: "text", text: " \n\t" },
-            { type: "text", text: "  Keep this system prompt.  " },
-          ],
-          messages: [
-            Message.user([
-              { type: "text", text: "" },
-              { type: "text", text: "  Use the tool.  " },
-              { type: "text", text: " \n\t" },
-            ]),
-            Message.assistant([
-              { type: "text", text: "", providerMetadata: { anthropic: { itemId: "ignored" } } },
-              { type: "reasoning", text: "", providerMetadata: { anthropic: { signature: "sig_1" } } },
-              ToolCallPart.make({ id: "call_1", name: "lookup", input: {} }),
-            ]),
-            Message.tool({
-              id: "call_1",
-              name: "lookup",
-              resultType: "content",
-              result: [
-                { type: "text", text: " \n\t" },
-                { type: "text", text: " Tool result. " },
-              ],
-            }),
-            Message.assistant(" \n\t"),
-            Message.user("Continue."),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        system: [{ type: "text", text: "  Keep this system prompt.  " }],
-        messages: [
-          { role: "user", content: [{ type: "text", text: "  Use the tool.  " }] },
-          {
-            role: "assistant",
-            content: [
-              { type: "thinking", thinking: "", signature: "sig_1" },
-              { type: "tool_use", id: "call_1", name: "lookup", input: {} },
-            ],
-          },
-          {
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                tool_use_id: "call_1",
-                content: [{ type: "text", text: " Tool result. " }],
-              },
-            ],
-          },
-          { role: "user", content: [{ type: "text", text: "Continue." }] },
-        ],
-      })
-    }),
-  )
-
-  it.effect("filters empty native system update blocks", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model: opus48,
-          messages: [
-            Message.user("Before."),
-            Message.system([
-              { type: "text", text: " \n\t" },
-              { type: "text", text: "Operator update." },
-            ]),
-            Message.assistant("After."),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages[1]).toEqual({
-        role: "system",
-        content: [{ type: "text", text: "Operator update." }],
-      })
-    }),
-  )
-
  it.effect("lowers adaptive thinking settings with effort", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -409,34 +322,11 @@ describe("Anthropic Messages route", () => {
          { role: "user", content: [{ type: "tool_result", tool_use_id: "call_1", content: '{"forecast":"sunny"}' }] },
        ],
        stream: true,
-        max_tokens: 32_000,
+        max_tokens: 4096,
      })
    }),
  )

-  it.effect("scrubs outbound tool call IDs without truncating them", () =>
-    Effect.gen(function* () {
-      const id = `functions.lookup:1|${"x".repeat(64)}`
-      const scrubbed = `functions_lookup_1_${"x".repeat(64)}`
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id, name: "lookup", input: {} })]),
-            Message.tool({ id, name: "lookup", result: "done" }),
-          ],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toMatchObject([
-        { role: "assistant", content: [{ type: "tool_use", id: scrubbed, name: "lookup", input: {} }] },
-        { role: "user", content: [{ type: "tool_result", tool_use_id: scrubbed }] },
-      ])
-      expect(scrubbed.length).toBeGreaterThan(64)
-    }),
-  )
-
  it.effect("batches parallel tool results into one Anthropic user message", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -750,60 +640,7 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("ignores unknown named SSE events", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseRaw(
-              sseNamedEvent("message_start", {
-                type: "message_start",
-                message: { usage: { input_tokens: 5 } },
-              }),
-              sseNamedEvent("proxy.stats", "not json"),
-              sseNamedEvent("content_block_start", {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "text", text: "" },
-              }),
-              sseNamedEvent("content_block_delta", {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "text_delta", text: "Hello" },
-              }),
-              sseNamedEvent("content_block_stop", { type: "content_block_stop", index: 0 }),
-              sseNamedEvent("message_delta", {
-                type: "message_delta",
-                delta: { stop_reason: "end_turn" },
-                usage: { output_tokens: 1 },
-              }),
-              sseNamedEvent("message_stop", { type: "message_stop" }),
-              sseNamedEvent("proxy.done", "still not json"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([{ type: "text", text: "Hello" }])
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "end_turn" })
-    }),
-  )
-
-  it.effect("rejects malformed recognized SSE events", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseRaw(sseNamedEvent("message_start", "[DONE]")))),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({
-        _tag: "InvalidProviderOutput",
-        message: "Invalid anthropic/anthropic-messages stream event",
-      })
-    }),
-  )
-
-  it.effect("maps nullable input tokens and preserves unknown Anthropic usage fields", () =>
+  it.effect("maps thinking tokens and preserves unknown Anthropic usage fields", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
        Effect.provide(
@@ -826,7 +663,6 @@ describe("Anthropic Messages route", () => {
                type: "message_delta",
                delta: { stop_reason: "end_turn" },
                usage: {
-                  input_tokens: null,
                  output_tokens: 8,
                  server_tool_use: { web_search_requests: 2, terminal_counter: 3 },
                  output_tokens_details: { terminal_detail: "preserved" },
@@ -846,7 +682,7 @@ describe("Anthropic Messages route", () => {
        totalTokens: 15,
        providerMetadata: {
          anthropic: {
-            input_tokens: null,
+            input_tokens: 5,
            cache_read_input_tokens: 2,
            service_tier: "standard",
            cache_creation: { ephemeral_5m_input_tokens: 1 },
@@ -1503,14 +1339,14 @@ describe("Anthropic Messages route", () => {
            Message.assistant([
              {
                type: "tool-call",
-                id: "srvtoolu.abc",
+                id: "srvtoolu_abc",
                name: "web_search",
                input: { query: "effect 4" },
                providerExecuted: true,
              },
              {
                type: "tool-result",
-                id: "srvtoolu.abc",
+                id: "srvtoolu_abc",
                name: "web_search",
                result: { type: "json", value: [{ url: "https://example.com" }] },
                providerExecuted: true,
@@ -139,95 +139,6 @@ describe("Gemini route", () => {
    }),
  )

-  it.effect("keeps system updates separate from function responses", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } })]),
-            Message.tool({ id: "call_1", name: "lookup", result: "done", resultType: "text" }),
-            Message.system("Update."),
-            Message.system("Later update."),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [{ functionCall: { id: undefined, name: "lookup", args: { query: "weather" } } }],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: undefined,
-                name: "lookup",
-                response: { name: "lookup", content: "done" },
-              },
-            },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            { text: "<system-update>\nUpdate.\n</system-update>" },
-            { text: "<system-update>\nLater update.\n</system-update>" },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("merges parallel tool results into one function-response turn", () =>
-    Effect.gen(function* () {
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              ToolCallPart.make({ id: "call_1", name: "lookup", input: { query: "weather" } }),
-              ToolCallPart.make({ id: "call_2", name: "lookup", input: { query: "time" } }),
-            ]),
-            Message.tool({ id: "call_1", name: "lookup", result: "sunny", resultType: "text" }),
-            Message.tool({ id: "call_2", name: "lookup", result: "noon", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            { functionCall: { id: undefined, name: "lookup", args: { query: "weather" } } },
-            { functionCall: { id: undefined, name: "lookup", args: { query: "time" } } },
-          ],
-        },
-        {
-          role: "user",
-          parts: [
-            {
-              functionResponse: {
-                id: undefined,
-                name: "lookup",
-                response: { name: "lookup", content: "sunny" },
-              },
-            },
-            {
-              functionResponse: {
-                id: undefined,
-                name: "lookup",
-                response: { name: "lookup", content: "noon" },
-              },
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("prepares multimodal user input and tool history", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
@@ -96,7 +96,7 @@ describe("Google Vertex providers", () => {
                "https://aiplatform.eu.rep.googleapis.com/v1/projects/vertex-project/locations/eu/publishers/anthropic/models/claude-sonnet-4-6:streamRawPredict",
              )
              expect(request.headers.get("authorization")).toBe("Bearer vertex-token")
-              expect(request.headers.get("anthropic-version")).toBe("2023-06-01")
+              expect(request.headers.get("anthropic-version")).toBeNull()
              const body = yield* Effect.promise(() => request.json())
              expect(body).toMatchObject({
                anthropic_version: "vertex-2023-10-16",
@@ -664,74 +664,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("preserves streamed refusals as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ role: "assistant", refusal: "I can't" }),
-              deltaChunk({ refusal: " help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("I can't help with that.")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "stop" })
-      expect(response.message.content).toEqual([{ type: "text", text: "I can't help with that." }])
-
-      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "I can't help with that." }])
-    }),
-  )
-
-  it.effect("orders metadata-only reasoning before refusal output", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning_details: [] } }] },
-              deltaChunk({ refusal: "I can't help with that." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { openai: { reasoningDetails: [] } } },
-        {
-          type: "text",
-          text: "I can't help with that.",
-        },
-      ])
-    }),
-  )
-
-  it.effect("joins content and refusal deltas into ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ refusal: "No." }),
-              deltaChunk({ content: " Alternative." }),
-              deltaChunk({ refusal: " Still no." }),
-              deltaChunk({}, "stop"),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("No. Alternative. Still no.")
-      expect(response.events.filter(LLMEvent.is.textStart).map((event) => event.id)).toEqual(["text-0"])
-      expect(response.events.filter(LLMEvent.is.textEnd).map((event) => event.id)).toEqual(["text-0"])
-    }),
-  )
-
  it.effect("parses and replays OpenAI-compatible reasoning fields", () =>
    Effect.gen(function* () {
      const fields = ["reasoning_content", "reasoning", "reasoning_text"] as const
@@ -73,7 +73,7 @@ describe("Open Responses-compatible route", () => {
      expect(prepared.body.input).toEqual([
        { role: "user", content: [{ type: "input_text", text: "Before." }] },
        { role: "developer", content: "Operator update." },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -113,67 +113,11 @@ describe("Open Responses-compatible route", () => {
      )

      expect(prepared.body).toMatchObject({
-        input: [{ type: "message", role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
+        input: [{ role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
      })
    }),
  )

-  it.effect("preserves standard refusal content as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const model = configure({
-        apiKey: "test-key",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-      }).model("example-model")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Unsafe request" })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                output_index: 0,
-                item: { type: "message", id: "msg_refusal", content: [] },
-              },
-              {
-                type: "response.refusal.done",
-                item_id: "msg_refusal",
-                refusal: "I can't help with that.",
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: {
-                  type: "message",
-                  id: "msg_refusal",
-                  content: [{ type: "refusal", refusal: "I can't help with that." }],
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "I can't help with that.",
-          providerMetadata: { openresponses: { itemId: "msg_refusal" } },
-        },
-      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "msg_refusal",
-          role: "assistant",
-          content: [{ type: "output_text", text: "I can't help with that." }],
-        },
-      ])
-    }),
-  )
-
  it.effect("reads standard Open Responses options", () =>
    Effect.gen(function* () {
      const model = configure({
@@ -182,10 +126,6 @@ describe("Open Responses-compatible route", () => {
        providerOptions: {
          reasoningEffort: "low",
          store: true,
-          metadata: { environment: "test" },
-          safetyIdentifier: "user_123",
-          streamOptions: { includeObfuscation: false },
-          topLogprobs: 3,
          truncation: "auto",
          allowedTools: { toolNames: ["lookup"] },
          maxToolCalls: 2,
@@ -196,7 +136,6 @@ describe("Open Responses-compatible route", () => {
        LLM.request({
          model,
          prompt: "Think.",
-          generation: { presencePenalty: 0.2, frequencyPenalty: -0.1 },
          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
        }),
      )
@@ -204,12 +143,6 @@ describe("Open Responses-compatible route", () => {
      expect(prepared.body).toMatchObject({
        reasoning: { effort: "low" },
        store: true,
-        metadata: { environment: "test" },
-        safety_identifier: "user_123",
-        stream_options: { include_obfuscation: false },
-        top_logprobs: 3,
-        presence_penalty: 0.2,
-        frequency_penalty: -0.1,
        truncation: "auto",
        tool_choice: {
          type: "allowed_tools",
@@ -1,216 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { Socket } from "effect/unstable/socket"
-import { LLM, LLMRequest, Message, ToolRuntime } from "../../src/index.js"
-import {
-  LLMClient,
-  WebSocketTransport,
-  type ChannelCheckpoint,
-  type ChannelObservation,
-  type WebSocketChannelExchange,
-  type WebSocketChannelExecutor,
-  type WebSocketConnection,
-} from "../../src/route.js"
-import { configure } from "../../src/providers/openai.js"
-import { decodeJson } from "../../src/protocols/shared.js"
-import { weatherRuntimeTool, weatherTool, weatherToolName } from "../recorded-scenarios.js"
-import { recordedTests } from "../recorded-test.js"
-
-const model = configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" }).responses("gpt-5.5")
-const recorded = recordedTests({
-  prefix: "openai-responses-websocket",
-  provider: "openai",
-  protocol: "openai-responses",
-  requires: ["OPENAI_API_KEY"],
-  tags: ["transport:websocket"],
-  metadata: { transport: "websocket", model: model.id },
-})
-
-const observationFrame = (observation: ChannelObservation) => {
-  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
-    return Effect.succeed(observation.frame)
-  return Effect.fail(observation.error)
-}
-
-const terminal = (observation: ChannelObservation) => observation.type !== "frame"
-
-// This deliberately models only sequential test traffic. Core owns production connection pooling and recovery.
-const makeChannel = Effect.gen(function* () {
-  const constructor = yield* Socket.WebSocketConstructor
-  let connection: WebSocketConnection | undefined
-  let checkpoint: ChannelCheckpoint | undefined
-  let pending: ChannelCheckpoint | undefined
-  let opens = 0
-  const sent: unknown[] = []
-
-  const close = Effect.suspend(() => {
-    const current = connection
-    connection = undefined
-    return current ? current.close : Effect.void
-  })
-  yield* Effect.addFinalizer(() => close)
-
-  const executor: WebSocketChannelExecutor = {
-    execute: (exchange: WebSocketChannelExchange) =>
-      Effect.gen(function* () {
-        if (!connection) {
-          connection = yield* WebSocketTransport.open(exchange.connect).pipe(
-            Effect.provideService(Socket.WebSocketConstructor, constructor),
-          )
-          opens += 1
-        }
-        const current = connection
-        const create = yield* exchange.driver.create(checkpoint)
-        if (create.mode === "full") checkpoint = undefined
-        pending = undefined
-        sent.push(decodeJson(create.message))
-        yield* current.sendText(create.message)
-        const decoder = new TextDecoder()
-        return {
-          frames: current.messages.pipe(
-            Stream.map((message) => WebSocketTransport.messageText(message, decoder)),
-            Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
-            Stream.tap((observation) =>
-              Effect.sync(() => {
-                if (!terminal(observation)) return
-                pending = observation.type === "completed" ? observation.checkpoint : undefined
-                if (observation.type !== "completed") checkpoint = undefined
-              }),
-            ),
-            Stream.takeUntil(terminal),
-            Stream.mapEffect(observationFrame),
-          ),
-          complete: Effect.sync(() => {
-            checkpoint = pending
-            pending = undefined
-          }),
-        }
-      }),
-  }
-
-  return {
-    executor,
-    sent,
-    opens: () => opens,
-    reconnect: (preserveCheckpoint = false) =>
-      close.pipe(
-        Effect.andThen(
-          Effect.sync(() => {
-            pending = undefined
-            if (!preserveCheckpoint) checkpoint = undefined
-          }),
-        ),
-      ),
-  }
-})
-
-describe("OpenAI Responses WebSocket recorded", () => {
-  recorded.effect.with("continues a tool call over one socket", { tags: ["tool", "continuation"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_tool",
-        model,
-        system: "Call get_weather once, then reply exactly: Paris is sunny.",
-        prompt: "What is the weather in Paris?",
-        tools: [weatherTool],
-        generation: { maxTokens: 50 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const call = first.toolCalls[0]
-      if (!call) yield* Effect.die("Expected get_weather tool call")
-      const result = yield* ToolRuntime.dispatch({ [weatherToolName]: weatherRuntimeTool }, call)
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [
-            ...request.messages,
-            first.message,
-            Message.tool({ id: call.id, name: call.name, result: result.result }),
-          ],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(second.text).toBe("Paris is sunny.")
-      expect(channel.opens()).toBe(1)
-      expect(channel.sent).toHaveLength(2)
-      expect(channel.sent[1]).toMatchObject({
-        previous_response_id: expect.any(String),
-        input: [{ type: "function_call_output", call_id: call.id, output: expect.any(String) }],
-      })
-    }),
-  )
-
-  recorded.effect.with("reconstructs full context after reconnect", { tags: ["reconnect", "full-context"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_reconnect",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Alpha.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      yield* channel.reconnect()
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [...request.messages, first.message, Message.user("Reply exactly: Beta.")],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(first.text).toBe("Alpha.")
-      expect(second.text).toBe("Beta.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[1]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Alpha." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Alpha." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Beta." }] },
-        ],
-      })
-    }),
-  )
-
-  recorded.effect.with("recovers from explicit continuation rejection", { tags: ["continuation", "recovery"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_rejection",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Ready.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const continuation = LLMRequest.update(request, {
-        messages: [...request.messages, first.message, Message.user("Reply exactly: Recovered.")],
-      })
-      yield* channel.reconnect(true)
-      const rejected = yield* LLMClient.generate(continuation, { webSocket: channel.executor }).pipe(Effect.flip)
-      const recovered = yield* LLMClient.generate(continuation, { webSocket: channel.executor })
-
-      expect(rejected).toMatchObject({
-        reason: { _tag: "Transport", delivery: "rejected", recovery: "retry-full" },
-      })
-      expect(recovered.text).toBe("Recovered.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).toHaveProperty("previous_response_id", expect.any(String))
-      expect(channel.sent[2]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[2]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Ready." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Ready." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Recovered." }] },
-        ],
-      })
-    }),
-  )
-})
@@ -263,7 +263,7 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.input).toEqual([
        { role: "user", content: [{ type: "input_text", text: "Before." }] },
        { role: "developer", content: "Operator update." },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -485,7 +485,7 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("continues store-false reasoning while retaining the output item ID", () =>
+  it.effect("continues store-false reasoning without replaying the output-only item ID", () =>
    Effect.gen(function* () {
      const firstInput = [{ role: "user", content: [{ type: "input_text", text: "Think" }] }]
      const request = { type: "response.create", model: "gpt-5.2", store: false, input: firstInput }
@@ -515,7 +515,6 @@ describe("OpenAI Responses route", () => {
          ...firstInput,
          {
            type: "reasoning",
-            id: "rs_1",
            summary: [{ type: "summary_text", text: "Thought" }],
            encrypted_content: "encrypted",
          },
@@ -691,134 +690,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("builds xAI WebSocket requests without OpenAI handshake headers", () =>
-    Effect.gen(function* () {
-      const deps = Layer.succeed(
-        RequestExecutor.Service,
-        RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
-      )
-      const response = yield* LLMClient.generate(LLM.request({ model: xaiModel, prompt: "Say hello." }), {
-        webSocket: {
-          execute: (exchange) =>
-            Effect.gen(function* () {
-              expect(exchange.connect.url).toBe("wss://api.x.ai/v1/responses")
-              expect(exchange.connect.rotateAfterMs).toBe(24 * 60 * 1000)
-              expect(exchange.connect.headers.authorization).toBe("Bearer test")
-              expect(exchange.connect.headers["openai-beta"]).toBeUndefined()
-              expect(JSON.parse((yield* exchange.driver.create(undefined)).message)).toMatchObject({
-                type: "response.create",
-                model: "grok-4.5",
-                store: false,
-              })
-              return {
-                frames: Stream.make(
-                  JSON.stringify({ type: "response.created", response: { id: "resp_xai" } }),
-                  JSON.stringify({ type: "response.completed", response: { id: "resp_xai" } }),
-                ),
-                complete: Effect.void,
-              }
-            }),
-        },
-      }).pipe(Effect.provide(LLMClient.layer.pipe(Layer.provide(deps))))
-
-      expect(response.finishReason.normalized).toBe("stop")
-    }),
-  )
-
-  it.effect("builds Azure WebSocket requests with v1 URLs and bearer auth", () =>
-    Effect.gen(function* () {
-      const deps = Layer.succeed(
-        RequestExecutor.Service,
-        RequestExecutor.Service.of({ execute: () => Effect.die("unexpected HTTP request") }),
-      )
-      const cases = [
-        {
-          model: Azure.configure({ resourceName: "opencode-test", apiKey: "azure-key" }).responses("deployment"),
-          authorization: "Bearer azure-key",
-        },
-        {
-          model: Azure.configure({ resourceName: "opencode-test", auth: Auth.bearer("entra-token") }).responses(
-            "deployment",
-          ),
-          authorization: "Bearer entra-token",
-        },
-      ]
-
-      yield* Effect.forEach(cases, (item) =>
-        LLMClient.generate(LLM.request({ model: item.model, prompt: "Say hello." }), {
-          webSocket: {
-            execute: (exchange) =>
-              Effect.gen(function* () {
-                expect(exchange.connect.url).toBe("wss://opencode-test.openai.azure.com/openai/v1/responses")
-                expect(exchange.connect.rotateAfterMs).toBe(55 * 60 * 1000)
-                expect(exchange.connect.headers.authorization).toBe(item.authorization)
-                expect(exchange.connect.headers["api-key"]).toBeUndefined()
-                expect(exchange.connect.headers["openai-beta"]).toBeUndefined()
-                expect(JSON.parse((yield* exchange.driver.create(undefined)).message)).toMatchObject({
-                  type: "response.create",
-                  model: "deployment",
-                  store: false,
-                })
-                return {
-                  frames: Stream.make(
-                    JSON.stringify({ type: "response.created", response: { id: "resp_azure" } }),
-                    JSON.stringify({ type: "response.completed", response: { id: "resp_azure" } }),
-                  ),
-                  complete: Effect.void,
-                }
-              }),
-          },
-        }).pipe(Effect.provide(LLMClient.layer.pipe(Layer.provide(deps)))),
-      )
-    }),
-  )
-
-  it.effect("keeps unsupported Azure endpoints and API versions on HTTP", () =>
-    Effect.gen(function* () {
-      const cases = [
-        {
-          model: Azure.configure({
-            resourceName: "opencode-test",
-            apiKey: "azure-key",
-            apiVersion: "2025-04-01-preview",
-          }).responses("deployment"),
-          url: "https://opencode-test.openai.azure.com/openai/v1/responses?api-version=2025-04-01-preview",
-        },
-        {
-          model: Azure.configure({
-            resourceName: "opencode-test",
-            apiKey: "azure-key",
-            useDeploymentBasedUrls: true,
-          }).responses("deployment"),
-          url: "https://opencode-test.openai.azure.com/openai/deployments/deployment/responses?api-version=v1",
-        },
-        {
-          model: Azure.configure({ baseURL: "https://gateway.example/azure", apiKey: "azure-key" }).responses(
-            "deployment",
-          ),
-          url: "https://gateway.example/azure/responses",
-        },
-      ]
-
-      yield* Effect.forEach(cases, (item) =>
-        LLMClient.generate(LLM.request({ model: item.model, prompt: "Say hello." }), {
-          webSocket: { execute: () => Effect.die("unexpected WebSocket request") },
-        }).pipe(
-          Effect.provide(
-            dynamicResponse((input) =>
-              Effect.gen(function* () {
-                expect(input.request.url).toBe(item.url)
-                return input.respond(sseEvents({ type: "response.completed", response: {} }), {
-                  headers: { "content-type": "text/event-stream" },
-                })
-              }),
-            ),
-          ),
-        ),
-      )
-    }),
-  )
-
  it.effect("uses exactly one HTTP request when no WebSocket executor is supplied", () =>
    Effect.gen(function* () {
      const attempts = yield* Ref.make(0)
@@ -1413,7 +1284,6 @@ describe("OpenAI Responses route", () => {
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
          prompt: "think",
          promptCacheKey: "session_123",
-          generation: { presencePenalty: 0.25, frequencyPenalty: -0.25 },
          tools: [
            ToolDefinition.make({ name: "read", description: "Read a file", inputSchema: { type: "object" } }),
            ToolDefinition.make({ name: "grep", description: "Search files", inputSchema: { type: "object" } }),
@@ -1423,10 +1293,6 @@ describe("OpenAI Responses route", () => {
            reasoningEffort: "high",
            reasoningSummary: "auto",
            include: ["reasoning.encrypted_content"],
-            metadata: { environment: "test", tenant: "acme" },
-            safetyIdentifier: "user_123",
-            streamOptions: { includeObfuscation: false },
-            topLogprobs: 5,
            truncation: "disabled",
            allowedTools: { toolNames: ["read", "grep"], mode: "required" },
            maxToolCalls: 4,
@@ -1440,12 +1306,6 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.include).toEqual(["reasoning.encrypted_content"])
      expect(prepared.body.reasoning).toEqual({ effort: "high", summary: "auto" })
      expect(prepared.body.text).toEqual({ verbosity: "low" })
-      expect(prepared.body.metadata).toEqual({ environment: "test", tenant: "acme" })
-      expect(prepared.body.safety_identifier).toBe("user_123")
-      expect(prepared.body.stream_options).toEqual({ include_obfuscation: false })
-      expect(prepared.body.top_logprobs).toBe(5)
-      expect(prepared.body.presence_penalty).toBe(0.25)
-      expect(prepared.body.frequency_penalty).toBe(-0.25)
      expect(prepared.body.truncation).toBe("disabled")
      expect(prepared.body.tool_choice).toEqual({
        type: "allowed_tools",
@@ -1613,7 +1473,7 @@ describe("OpenAI Responses route", () => {
      expect(response.text).toBe("Hello!")
      expect(response.events).toEqual([
        { type: "step-start", index: 0 },
-        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-start", id: "msg_1" },
        { type: "text-delta", id: "msg_1", text: "Hello" },
        { type: "text-delta", id: "msg_1", text: "!" },
        { type: "text-end", id: "msg_1" },
@@ -1634,108 +1494,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("preserves standard refusal content as ordinary assistant text", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.added",
-                output_index: 0,
-                item: { type: "message", id: "msg_refusal", content: [] },
-              },
-              {
-                type: "response.content_part.added",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                part: { type: "refusal", refusal: "" },
-              },
-              {
-                type: "response.refusal.delta",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                delta: "I can't",
-              },
-              {
-                type: "response.refusal.delta",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                delta: " help with that.",
-              },
-              {
-                type: "response.refusal.done",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                refusal: "I can't help with that.",
-              },
-              {
-                type: "response.content_part.done",
-                item_id: "msg_refusal",
-                output_index: 0,
-                content_index: 0,
-                part: { type: "refusal", refusal: "I can't help with that." },
-              },
-              {
-                type: "response.output_item.done",
-                output_index: 0,
-                item: {
-                  type: "message",
-                  id: "msg_refusal",
-                  phase: "final_answer",
-                  content: [{ type: "refusal", refusal: "I can't help with that." }],
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.text).toBe("I can't help with that.")
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: undefined })
-      expect(response.message.content).toEqual([
-        {
-          type: "text",
-          text: "I can't help with that.",
-          providerMetadata: { openai: { itemId: "msg_refusal", phase: "final_answer" } },
-        },
-      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "message",
-          id: "msg_refusal",
-          role: "assistant",
-          content: [{ type: "output_text", text: "I can't help with that." }],
-          phase: "final_answer",
-        },
-      ])
-    }),
-  )
-
-  it.effect("rejects malformed refusal events", () =>
-    Effect.gen(function* () {
-      const events = [
-        { type: "response.refusal.delta", output_index: 0, content_index: 0, delta: "missing item" },
-        { type: "response.refusal.delta", item_id: "msg_1", output_index: 0, content_index: 0 },
-        { type: "response.refusal.done", item_id: "msg_1", output_index: 0, content_index: 0 },
-      ]
-      for (const event of events) {
-        const error = yield* LLMClient.generate(request).pipe(
-          Effect.provide(fixedResponse(sseEvents(event))),
-          Effect.flip,
-        )
-        expect(error.reason._tag).toBe("InvalidProviderOutput")
-      }
-    }),
-  )
-
  it.effect("preserves and replays assistant message phases", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
@@ -1774,39 +1532,33 @@ describe("OpenAI Responses route", () => {
        {
          type: "text",
          text: "Checking.",
-          providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
+          providerMetadata: { openai: { phase: "commentary" } },
        },
        {
          type: "text",
          text: "Finished.",
-          providerMetadata: { openai: { itemId: "msg_final", phase: "final_answer" } },
+          providerMetadata: { openai: { phase: "final_answer" } },
        },
        {
          type: "text",
          text: "Unclassified.",
-          providerMetadata: { openai: { itemId: "msg_null", phase: null } },
+          providerMetadata: { openai: { phase: null } },
        },
      ])

      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(prepared.body.input).toEqual([
        {
-          type: "message",
-          id: "msg_commentary",
          role: "assistant",
          content: [{ type: "output_text", text: "Checking." }],
          phase: "commentary",
        },
        {
-          type: "message",
-          id: "msg_final",
          role: "assistant",
          content: [{ type: "output_text", text: "Finished." }],
          phase: "final_answer",
        },
        {
-          type: "message",
-          id: "msg_null",
          role: "assistant",
          content: [{ type: "output_text", text: "Unclassified." }],
          phase: null,
@@ -1900,12 +1652,12 @@ describe("OpenAI Responses route", () => {
      )

      expect(response.events.filter((event) => event.type.startsWith("text-"))).toEqual([
-        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text-start", id: "msg_1" },
        { type: "text-delta", id: "msg_1", text: "First" },
-        { type: "text-end", id: "msg_1", providerMetadata: undefined },
-        { type: "text-start", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
+        { type: "text-end", id: "msg_1" },
+        { type: "text-start", id: "msg_2" },
        { type: "text-delta", id: "msg_2", text: "Second" },
-        { type: "text-end", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
+        { type: "text-end", id: "msg_2" },
      ])
    }),
  )
@@ -1937,7 +1689,7 @@ describe("OpenAI Responses route", () => {
      expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
      expect(response.message.content).toEqual([
        { type: "reasoning", text: "thinking" },
-        { type: "text", text: "Hello", providerMetadata: { openai: { itemId: "msg_1" } } },
+        { type: "text", text: "Hello" },
      ])
    }),
  )
@@ -2098,7 +1850,6 @@ describe("OpenAI Responses route", () => {
                  { role: "user", content: [{ type: "input_text", text: "What changed?" }] },
                  {
                    type: "reasoning",
-                    id: "rs_1",
                    encrypted_content: "encrypted-state",
                    summary: [{ type: "summary_text", text: "Checked the previous diff." }],
                  },
@@ -2106,6 +1857,7 @@ describe("OpenAI Responses route", () => {
                  { role: "user", content: [{ type: "input_text", text: "Summarize it." }] },
                ],
              })
+              expect(body.input[1]).not.toHaveProperty("id")
              return input.respond(
                sseEvents(
                  { type: "response.output_text.delta", item_id: "msg_1", delta: "Parser now round-trips reasoning." },
@@ -2149,14 +1901,13 @@ describe("OpenAI Responses route", () => {
      )

      expect(prepared.body.input).toEqual([
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "Before." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "Before." }] },
        {
          type: "reasoning",
-          id: "rs_1",
          encrypted_content: "encrypted-state",
          summary: [{ type: "summary_text", text: "Checked order." }],
        },
-        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
      ])
    }),
  )
@@ -2288,7 +2039,6 @@ describe("OpenAI Responses route", () => {
      expect(prepared.body.input).toEqual([
        {
          type: "reasoning",
-          id: "rs_1",
          encrypted_content: "encrypted-state",
          summary: [
            { type: "summary_text", text: "First" },
@@ -2421,50 +2171,6 @@ describe("OpenAI Responses route", () => {
          usage,
        },
      ])
-
-      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
-      expect(prepared.body.input).toEqual([
-        {
-          type: "function_call",
-          id: "item_1",
-          call_id: "call_1",
-          name: "lookup",
-          arguments: '{"query":"weather"}',
-        },
-      ])
-    }),
-  )
-
-  it.effect("finalizes a pending function call at response completion", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "" },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.filter((event) => LLMEvent.is.toolInputEnd(event) || LLMEvent.is.toolCall(event))).toEqual(
-        [
-          {
-            type: "tool-input-end",
-            id: "call_1",
-            name: "lookup",
-            providerMetadata: { openai: { itemId: "item_1" } },
-          },
-          {
-            type: "tool-call",
-            id: "call_1",
-            name: "lookup",
-            input: {},
-            providerExecuted: undefined,
-            providerMetadata: { openai: { itemId: "item_1" } },
-          },
-        ],
-      )
-      expect(response.finishReason.normalized).toBe("tool-calls")
    }),
  )

@@ -2531,35 +2237,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("retains function call item metadata when output_item.added is absent", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              {
-                type: "response.output_item.done",
-                item: {
-                  type: "function_call",
-                  id: "item_1",
-                  call_id: "call_1",
-                  name: "lookup",
-                  arguments: '{"query":"weather"}',
-                },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({
-        id: "call_1",
-        providerMetadata: { openai: { itemId: "item_1" } },
-      })
-    }),
-  )
-
  it.effect("decodes web_search_call as provider-executed tool-call + tool-result", () =>
    Effect.gen(function* () {
      const item = {
@@ -1,7 +1,5 @@
 import { HttpRecorder } from "@opencode-ai/http-recorder"
-import { NodeSocket } from "@effect/platform-node"
 import { Layer } from "effect"
-import { Socket } from "effect/unstable/socket"
 import * as path from "node:path"
 import { fileURLToPath } from "node:url"
 import { LLMClient, RequestExecutor } from "../src/route.js"
@@ -18,7 +16,7 @@ import {
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings")

-type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService | Socket.WebSocketConstructor
+type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService

 type RecordedTestsOptions = RecordedGroupOptions & {
  readonly options?: HttpRecorder.RecorderOptions
@@ -71,7 +69,7 @@ export const recordedTests = (options: RecordedTestsOptions) =>
        ...metadata,
      }
      if (recording) {
-        if (process.env.CI !== undefined) throw new Error("Unset CI before recording cassettes")
+        if (process.env.CI !== undefined) throw new Error("Unset CI before recording HTTP cassettes")
        HttpRecorder.removeCassetteSync(cassette, { directory: FIXTURES_DIR })
      }
      const requestExecutor = RequestExecutor.layer.pipe(
@@ -83,16 +81,10 @@ export const recordedTests = (options: RecordedTestsOptions) =>
          }),
        ),
      )
-      const webSocket = HttpRecorder.layerWebSocketConstructor(cassette, {
-        ...recorderOptions,
-        directory: FIXTURES_DIR,
-        metadata: recorderMetadata,
-      }).pipe(Layer.provide(NodeSocket.layerWebSocketConstructorWS))
      return Layer.mergeAll(
        requestExecutor,
        LLMClient.layer.pipe(Layer.provide(requestExecutor)),
        ImageClient.layer.pipe(Layer.provide(requestExecutor)),
-        webSocket,
      )
    },
  })
@@ -2,34 +2,12 @@

 The app's high-volume performance diagnostics live under `packages/app/e2e/performance` and are excluded from normal local and CI Playwright discovery. The benchmark config builds the app and serves the production bundle before running scenarios serially.

-The `devex` category is the explicit exception to the production-build rule. It measures development commands from submission through a user-visible ready state and has its own Playwright configuration.
-
 Run the suite explicitly from `packages/app`:

 ```sh
 bun run test:bench
 ```

-Run the desktop development startup benchmark from the repository root:
-
-```sh
-bun run bench:devex
-```
-
-It runs five serial samples of the exact `bun dev:desktop` command. Each sample uses a fresh desktop profile, database, service configuration, service registration, and service process; the desktop selects an isolated ephemeral loopback endpoint. It removes desktop build output and the desktop Vite cache before every run; dependencies, Bun's package cache, and Electron remain installed. The harness stops only that sample's service; it does not stop or change the elected global OpenCode service. The measured endpoint is a visible Home page whose empty-state controls pass Playwright actionability checks. The command's Electron installation check remains inside the measured interval.
-
-Set `DESKTOP_STARTUP_RUNS` only for focused diagnostics:
-
-```sh
-DESKTOP_STARTUP_RUNS=1 bun run bench:devex
-```
-
-Set `OPENCODE_PERFORMANCE_TRACE_DIR` to capture the renderer's CDP trace from attachment through actionable Home:
-
-```sh
-DESKTOP_STARTUP_RUNS=1 OPENCODE_PERFORMANCE_TRACE_DIR=/tmp/opencode-desktop-traces bun run bench:devex
-```
-
 PowerShell:

 ```powershell
@@ -18,9 +18,9 @@ const categories = [
  "disabled-by-default-v8.cpu_profiler",
 ]

-export async function startChromeTrace(page: Page, name: string): Promise<undefined | (() => Promise<string>)> {
+export async function startChromeTrace(page: Page, name: string) {
  const directory = process.env.OPENCODE_PERFORMANCE_TRACE_DIR
-  if (!directory) return undefined
+  if (!directory) return

  const selectors = process.env.OPENCODE_PERFORMANCE_SELECTOR_TRACE === "1"
  const file = await prepareChromeTrace(directory, name, selectors)
@@ -1,26 +0,0 @@
-import { benchmark } from "../benchmark"
-import {
-  desktopBenchmarkContext,
-  runDesktopStartup,
-  summarizeDesktopStartup,
-  type DesktopStartupSample,
-} from "./desktop-startup"
-
-benchmark.describe("devex: desktop startup", () => {
-  benchmark("opens a cold desktop on Home", async ({ report }, testInfo) => {
-    benchmark.setTimeout(15 * 60_000)
-    const runs = Number(process.env.DESKTOP_STARTUP_RUNS ?? 5)
-    if (!Number.isSafeInteger(runs) || runs < 1) throw new Error("DESKTOP_STARTUP_RUNS must be a positive integer")
-
-    const samples: DesktopStartupSample[] = []
-    const context = await desktopBenchmarkContext(runs)
-    for (let run = 1; run <= runs; run++) {
-      const sample = await runDesktopStartup(run, testInfo).catch((error) => {
-        report(samples.length ? { samples, summary: summarizeDesktopStartup(samples) } : { samples }, context)
-        throw error
-      })
-      samples.push(sample)
-    }
-    report({ samples, summary: summarizeDesktopStartup(samples) }, context)
-  })
-})
@@ -1,526 +0,0 @@
-import { Service } from "@opencode-ai/client/service"
-import { chromium, expect, type Browser, type Page, type TestInfo } from "@playwright/test"
-import { spawn, spawnSync, type ChildProcess } from "node:child_process"
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
-import { tmpdir } from "node:os"
-import { join, resolve } from "node:path"
-import { startChromeTrace } from "../chrome-trace"
-
-const repository = resolve(import.meta.dirname, "../../../../..")
-const milestones = [
-  "bunRootScript",
-  "bunDesktopScript",
-  "desktopPrepared",
-  "mainBundleReady",
-  "preloadBundleReady",
-  "rendererDevServerReady",
-  "electronSpawnStarted",
-  "debugEndpointReady",
-  "electronStarted",
-  "serviceEnsureStarted",
-  "serviceSpawnRequested",
-  "serviceReady",
-  "backgroundLoadingReady",
-  "rendererViteConnected",
-  "rendererInitializationStarted",
-  "rendererInitializationReady",
-  "windowVisible",
-  "homeReady",
-] as const
-const phases = [
-  "desktopPreparation",
-  "viteMainBundle",
-  "vitePreloadBundle",
-  "rendererServerStartup",
-  "electronStartup",
-  "serviceSpawnWait",
-  "serviceProcessStartup",
-  "rendererStartup",
-  "visibleWindowToHome",
-] as const
-
-type Milestone = (typeof milestones)[number]
-type Phase = (typeof phases)[number]
-type ServiceInfo = { id: string; version: string; url: string; pid: number }
-
-export type DesktopStartupSample = {
-  run: number
-  commandToHomeReadyMs: number
-  milestonesMs: Record<Milestone, number>
-  phasesMs: Record<Phase, number>
-  service: Omit<ServiceInfo, "id">
-}
-
-export async function runDesktopStartup(run: number, testInfo: TestInfo) {
-  const profile = await createColdProfile()
-  const desktop = await Promise.resolve()
-    .then(() => startDesktop(profile))
-    .catch(async (error) => {
-      await rm(profile.root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-      throw error
-    })
-  try {
-    const page = await desktop.open()
-    const stopTrace = await startChromeTrace(page, `desktop-startup-${run}`)
-    try {
-      await startThemeObservation(page)
-      await waitForHome(page, desktop.mark)
-      await requireStableTheme(page)
-      return await desktop.result(run)
-    } finally {
-      await stopTrace?.()
-    }
-  } finally {
-    await desktop.close(testInfo, run)
-  }
-}
-
-export async function desktopBenchmarkContext(runs: number) {
-  const pkg = JSON.parse(await readFile(join(repository, "packages/desktop/package.json"), "utf8"))
-  const revision = spawnSync("git", ["rev-parse", "HEAD"], { cwd: repository })
-  if (revision.status !== 0) throw new Error("Failed to read the benchmark Git revision")
-  const status = spawnSync("git", ["status", "--porcelain"], { cwd: repository })
-  if (status.status !== 0) throw new Error("Failed to read the benchmark Git status")
-  const bun = spawnSync("bun", ["--version"], { cwd: repository })
-  if (bun.status !== 0) throw new Error("Failed to read the benchmark Bun version")
-  return {
-    arch: process.arch,
-    command: "bun dev:desktop",
-    runs,
-    profile: "fresh",
-    service: "isolated-cold",
-    install: "complete",
-    viteCache: "cold",
-    electronInstall: "present",
-    bunVersion: bun.stdout.toString().trim(),
-    electronVersion: pkg.devDependencies.electron,
-    electronViteVersionRange: pkg.devDependencies["electron-vite"],
-    gitCommit: revision.stdout.toString().trim(),
-    gitDirty: status.stdout.length > 0,
-    trace: Boolean(process.env.OPENCODE_PERFORMANCE_TRACE_DIR),
-  }
-}
-
-export function summarizeDesktopStartup(samples: DesktopStartupSample[]) {
-  return {
-    commandToHomeReadyMs: statistics(samples.map((sample) => sample.commandToHomeReadyMs)),
-    milestonesMs: Object.fromEntries(
-      milestones.map((name) => [name, statistics(samples.map((sample) => sample.milestonesMs[name]))]),
-    ),
-    phasesMs: Object.fromEntries(
-      phases.map((name) => [name, statistics(samples.map((sample) => sample.phasesMs[name]))]),
-    ),
-  }
-}
-
-export function milestoneForLine(line: string): Milestone | undefined {
-  const text = stripAnsi(line)
-  return milestonePatterns.find((item) => text.includes(item.text))?.name
-}
-
-const milestonePatterns: ReadonlyArray<{ name: Milestone; text: string }> = [
-  { name: "bunRootScript", text: "$ bun --cwd packages/desktop dev" },
-  { name: "bunDesktopScript", text: "$ bun ./scripts/dev.ts" },
-  { name: "desktopPrepared", text: "Copied dev icons from" },
-  { name: "mainBundleReady", text: "electron main process built successfully" },
-  { name: "preloadBundleReady", text: "electron preload scripts built successfully" },
-  { name: "rendererDevServerReady", text: "dev server running for the electron renderer process at:" },
-  { name: "electronSpawnStarted", text: "starting electron app..." },
-  { name: "debugEndpointReady", text: "DevTools listening on ws://" },
-  { name: "electronStarted", text: "app starting" },
-  { name: "serviceEnsureStarted", text: "starting v2 background service" },
-  { name: "serviceSpawnRequested", text: "v2 CLI background service starting" },
-  { name: "serviceReady", text: "v2 CLI background service ready" },
-  { name: "backgroundLoadingReady", text: "loading task finished" },
-  { name: "rendererViteConnected", text: "[vite] connected." },
-  { name: "rendererInitializationStarted", text: "awaiting server ready" },
-  { name: "rendererInitializationReady", text: "server ready" },
-  { name: "windowVisible", text: "main window visible" },
-]
-
-async function createColdProfile() {
-  await Promise.all(
-    ["packages/desktop/node_modules/.vite", "packages/desktop/out"].map((path) =>
-      rm(join(repository, path), { recursive: true, force: true }),
-    ),
-  )
-  const root = await mkdtemp(join(tmpdir(), "opencode-desktop-startup-"))
-  return initializeColdProfile(root).catch(async (error) => {
-    await rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-    throw error
-  })
-}
-
-async function initializeColdProfile(root: string) {
-  await Promise.all(
-    ["data", "config", "cache", "state", "desktop", "session", "home"].map((dir) =>
-      mkdir(join(root, dir), { recursive: true }),
-    ),
-  )
-  await Promise.all([
-    writeFile(
-      join(root, "desktop", "opencode.settings"),
-      JSON.stringify({ firstLaunchOnboardingComplete: true }),
-    ),
-    writeFile(join(root, "desktop", "opencode.global.dat"), JSON.stringify({ language: '{"locale":"en"}' })),
-  ])
-  const registration = join(root, "desktop", "opencode", "service-local.json")
-  await Service.stop({ file: registration })
-  return { root, registration }
-}
-
-function startDesktop(profile: Awaited<ReturnType<typeof createColdProfile>>) {
-  const started = performance.now()
-  const child = spawn("bun", ["dev:desktop"], {
-    cwd: repository,
-    detached: process.platform !== "win32",
-    env: {
-      ...process.env,
-      OPENCODE_CONFIG_DIR: join(profile.root, "config"),
-      OPENCODE_DB: join(profile.root, "data", "opencode.db"),
-      OPENCODE_TEST_HOME: join(profile.root, "home"),
-      OPENCODE_TEST_ONBOARDING: "0",
-      OPENCODE_DESKTOP_TEST_ROOT: profile.root,
-      OPENCODE_DESKTOP_REMOTE_DEBUGGING_PORT: "0",
-      OPENCODE_DESKTOP_DISABLE_PROTOCOL_REGISTRATION: "1",
-    },
-    stdio: ["ignore", "pipe", "pipe"],
-  })
-  if (!child.pid || !child.stdout || !child.stderr) throw new Error("Failed to start the desktop command")
-  const exited = childExit(child)
-  const observed: Partial<Record<Milestone, number>> = {}
-  const endpoint = Promise.withResolvers<string>()
-  const pageErrors: string[] = []
-  let browser: Browser | undefined
-  let service: ServiceInfo | undefined
-  const mark = (name: Milestone) => {
-    observed[name] ??= elapsed(started)
-  }
-  const record = (line: string) => {
-    const milestone = milestoneForLine(line)
-    if (milestone) mark(milestone)
-    const match = stripAnsi(line).match(/DevTools listening on (ws:\/\/\S+)/)
-    if (match?.[1]) endpoint.resolve(match[1])
-  }
-  const stdout = observeOutput(child.stdout, record)
-  const stderr = observeOutput(child.stderr, record)
-
-  return {
-    mark,
-    async open() {
-      const url = await Promise.race([
-        endpoint.promise,
-        exited.then((code) => {
-          throw new Error(`Desktop command exited with code ${code} before opening its debug endpoint`)
-        }),
-        sleep(120_000).then(() => {
-          throw new Error("Timed out waiting for the desktop debug endpoint")
-        }),
-      ])
-      browser = await chromium.connectOverCDP(url, { timeout: 120_000 })
-      const context = browser.contexts()[0]
-      if (!context) throw new Error("Electron did not expose a browser context")
-      await expect.poll(() => context.pages().length, { timeout: 120_000 }).toBeGreaterThan(0)
-      const page = context.pages()[0]
-      if (!page) throw new Error("Electron did not expose a renderer page")
-      page.on("pageerror", (error) => pageErrors.push(error.stack ?? error.message))
-      return page
-    },
-    async result(run: number): Promise<DesktopStartupSample> {
-      if (pageErrors.length) throw new Error(`Desktop renderer reported errors:\n\n${pageErrors.join("\n\n")}`)
-      service = await readService(profile)
-      const milestonesMs = requireMilestones(observed)
-      return {
-        run,
-        commandToHomeReadyMs: milestonesMs.homeReady,
-        milestonesMs,
-        phasesMs: calculatePhases(milestonesMs),
-        service: {
-          version: service.version,
-          url: service.url,
-          pid: service.pid,
-        },
-      }
-    },
-    async close(testInfo: TestInfo, run: number) {
-      const errors: unknown[] = []
-      await browser?.close().catch(() => undefined)
-      await stopProcessTree(child, exited).catch((error) => {
-        errors.push(error)
-        child.stdout?.destroy()
-        child.stderr?.destroy()
-      })
-      const [stdoutText, stderrText] = await Promise.all([stdout, stderr]).catch((error) => {
-        errors.push(error)
-        return ["", ""]
-      })
-      await Promise.all([
-        testInfo.attach(`desktop-startup-${run}-stdout`, { body: stdoutText, contentType: "text/plain" }),
-        testInfo.attach(`desktop-startup-${run}-stderr`, { body: stderrText, contentType: "text/plain" }),
-        pageErrors.length
-          ? testInfo.attach(`desktop-startup-${run}-page-errors`, {
-              body: pageErrors.join("\n\n"),
-              contentType: "text/plain",
-            })
-          : Promise.resolve(),
-      ]).catch((error) => errors.push(error))
-      await Service.stop({ file: profile.registration }).catch((error) => errors.push(error))
-      if (service && processAlive(service.pid))
-        errors.push(new Error(`Desktop service process ${service.pid} did not stop`))
-      await rm(profile.root, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch((error) =>
-        errors.push(error),
-      )
-      if (errors.length) throw new AggregateError(errors, "Desktop benchmark cleanup failed")
-    },
-  }
-}
-
-async function waitForHome(page: Page, mark: (name: Milestone) => void) {
-  await expect.poll(() => page.evaluate(() => document.visibilityState), { timeout: 120_000 }).toBe("visible")
-
-  const projects = page.getByRole("complementary", { name: "Projects", exact: true })
-  const sessions = page.getByRole("region", { name: "Recent sessions", exact: true })
-  const search = page.getByRole("textbox", { name: "Search sessions", exact: true })
-  const addProject = projects.locator('button[data-action="home-add-project-row"]')
-  await expect(projects).toBeVisible({ timeout: 120_000 })
-  await expect(sessions).toBeVisible()
-  await expect(search).toBeEditable()
-  await expect(sessions.getByText("Nothing here yet", { exact: true })).toBeVisible()
-  await expect(addProject).toHaveCount(1)
-  await addProject.click({ trial: true })
-  mark("homeReady")
-}
-
-type ThemeWindow = Window & {
-  __OPENCODE_THEME_STATES__?: string[]
-  __OPENCODE_THEME_OBSERVER__?: MutationObserver
-}
-
-async function startThemeObservation(page: Page) {
-  await page.addInitScript(installThemeObservation)
-  await page.evaluate(installThemeObservation)
-}
-
-async function requireStableTheme(page: Page) {
-  const states = await page.evaluate(() => {
-    const target = window as ThemeWindow
-    target.__OPENCODE_THEME_OBSERVER__?.disconnect()
-    return target.__OPENCODE_THEME_STATES__ ?? []
-  })
-  if (states.length !== 1) throw new Error(`Desktop theme changed during startup: ${states.join(" -> ")}`)
-}
-
-function installThemeObservation() {
-  const target = window as ThemeWindow
-  const observeRoot = () => {
-    const root = document.documentElement
-    if (!root) return false
-    const state = () => {
-      const theme = root.dataset.theme
-      const scheme = root.dataset.colorScheme
-      return theme && scheme ? `${theme}:${scheme}` : undefined
-    }
-    const initial = state()
-    target.__OPENCODE_THEME_STATES__ = initial ? [initial] : []
-    target.__OPENCODE_THEME_OBSERVER__ = new MutationObserver(() => {
-      const next = state()
-      if (!next) return
-      if (target.__OPENCODE_THEME_STATES__?.at(-1) !== next) target.__OPENCODE_THEME_STATES__?.push(next)
-    })
-    target.__OPENCODE_THEME_OBSERVER__.observe(root, {
-      attributes: true,
-      attributeFilter: ["data-theme", "data-color-scheme"],
-    })
-    return true
-  }
-  if (observeRoot()) return
-  const documentObserver = new MutationObserver(() => {
-    if (!observeRoot()) return
-    documentObserver.disconnect()
-  })
-  target.__OPENCODE_THEME_OBSERVER__ = documentObserver
-  documentObserver.observe(document, { childList: true })
-}
-
-async function observeOutput(stream: NodeJS.ReadableStream, record: (line: string) => void) {
-  const decoder = new TextDecoder()
-  const output: string[] = []
-  let pending = ""
-  for await (const chunk of stream) {
-    const text = typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
-    output.push(text)
-    pending += text
-    const lines = pending.split(/\r?\n/)
-    pending = lines.pop() ?? ""
-    lines.forEach(record)
-  }
-  const final = decoder.decode()
-  output.push(final)
-  pending += final
-  if (pending) record(pending)
-  return output.join("")
-}
-
-async function readService(profile: Awaited<ReturnType<typeof createColdProfile>>) {
-  const value: unknown = JSON.parse(await readFile(profile.registration, "utf8"))
-  if (!isServiceInfo(value)) throw new Error("Desktop service registration is invalid")
-  const url = new URL(value.url)
-  const port = Number(url.port)
-  if (url.hostname !== "127.0.0.1" || !Number.isInteger(port) || port <= 0)
-    throw new Error(`Desktop service used unexpected endpoint ${value.url}`)
-  if (!value.version.startsWith("2.0.0-local-"))
-    throw new Error(`Desktop service used unexpected version ${value.version}`)
-  return value
-}
-
-function isServiceInfo(value: unknown): value is ServiceInfo {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "id" in value &&
-    typeof value.id === "string" &&
-    "version" in value &&
-    typeof value.version === "string" &&
-    "url" in value &&
-    typeof value.url === "string" &&
-    "pid" in value &&
-    typeof value.pid === "number"
-  )
-}
-
-function requireMilestones(observed: Partial<Record<Milestone, number>>) {
-  const get = (name: Milestone) => {
-    const value = observed[name]
-    if (value === undefined) throw new Error(`Desktop startup did not report milestone: ${name}`)
-    return round(value)
-  }
-  return {
-    bunRootScript: get("bunRootScript"),
-    bunDesktopScript: get("bunDesktopScript"),
-    desktopPrepared: get("desktopPrepared"),
-    mainBundleReady: get("mainBundleReady"),
-    preloadBundleReady: get("preloadBundleReady"),
-    rendererDevServerReady: get("rendererDevServerReady"),
-    electronSpawnStarted: get("electronSpawnStarted"),
-    debugEndpointReady: get("debugEndpointReady"),
-    electronStarted: get("electronStarted"),
-    serviceEnsureStarted: get("serviceEnsureStarted"),
-    serviceSpawnRequested: get("serviceSpawnRequested"),
-    serviceReady: get("serviceReady"),
-    backgroundLoadingReady: get("backgroundLoadingReady"),
-    rendererViteConnected: get("rendererViteConnected"),
-    rendererInitializationStarted: get("rendererInitializationStarted"),
-    rendererInitializationReady: get("rendererInitializationReady"),
-    windowVisible: get("windowVisible"),
-    homeReady: get("homeReady"),
-  }
-}
-
-function calculatePhases(value: Record<Milestone, number>): Record<Phase, number> {
-  return {
-    desktopPreparation: value.desktopPrepared,
-    viteMainBundle: round(value.mainBundleReady - value.desktopPrepared),
-    vitePreloadBundle: round(value.preloadBundleReady - value.mainBundleReady),
-    rendererServerStartup: round(value.rendererDevServerReady - value.preloadBundleReady),
-    electronStartup: round(value.electronStarted - value.electronSpawnStarted),
-    serviceSpawnWait: round(value.serviceSpawnRequested - value.serviceEnsureStarted),
-    serviceProcessStartup: round(value.serviceReady - value.serviceSpawnRequested),
-    rendererStartup: round(value.homeReady - value.rendererViteConnected),
-    visibleWindowToHome: round(value.homeReady - value.windowVisible),
-  }
-}
-
-function statistics(values: number[]) {
-  if (!values.length) throw new Error("Cannot summarize an empty benchmark")
-  const sorted = values.toSorted((left, right) => left - right)
-  const median = medianOf(sorted)
-  return {
-    min: round(sorted[0]),
-    median: round(median),
-    max: round(sorted.at(-1)!),
-    medianAbsoluteDeviation: round(medianOf(sorted.map((value) => Math.abs(value - median)).toSorted((a, b) => a - b))),
-  }
-}
-
-function medianOf(sorted: number[]) {
-  const middle = Math.floor(sorted.length / 2)
-  if (sorted.length % 2) return sorted[middle]
-  return (sorted[middle - 1] + sorted[middle]) / 2
-}
-
-async function stopProcessTree(child: ChildProcess, exited: Promise<number | null>) {
-  if (!child.pid) throw new Error("Desktop command has no process ID")
-  if (process.platform !== "win32") return stopProcessGroup(child.pid, exited)
-  if (child.exitCode !== null || (await exitsWithin(child, exited, 2_000))) return
-  const kill = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
-    stdio: "ignore",
-  })
-  await childExit(kill)
-  if (await exitsWithin(child, exited, 10_000)) return
-  if (!(await exitsWithin(child, exited, 5_000))) throw new Error(`Desktop command process ${child.pid} did not stop`)
-}
-
-async function stopProcessGroup(pid: number, exited: Promise<number | null>) {
-  await Promise.race([exited, sleep(2_000)])
-  if (!processGroupAlive(pid)) return
-  process.kill(-pid, "SIGTERM")
-  if (await processGroupStopsWithin(pid, 10_000)) return
-  process.kill(-pid, "SIGKILL")
-  if (!(await processGroupStopsWithin(pid, 5_000))) throw new Error(`Desktop command process group ${pid} did not stop`)
-}
-
-async function processGroupStopsWithin(pid: number, timeout: number) {
-  const deadline = Date.now() + timeout
-  while (Date.now() < deadline) {
-    if (!processGroupAlive(pid)) return true
-    await sleep(50)
-  }
-  return !processGroupAlive(pid)
-}
-
-function processGroupAlive(pid: number) {
-  try {
-    process.kill(-pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function exitsWithin(child: ChildProcess, exited: Promise<number | null>, timeout: number) {
-  if (child.exitCode !== null) return true
-  const result = await Promise.race([exited.then(() => true), sleep(timeout).then(() => false)])
-  return result
-}
-
-function childExit(child: ChildProcess) {
-  return new Promise<number | null>((resolve, reject) => {
-    child.once("error", reject)
-    child.once("exit", (code) => resolve(code))
-  })
-}
-
-function sleep(milliseconds: number) {
-  return new Promise<void>((resolve) => setTimeout(resolve, milliseconds))
-}
-
-function processAlive(pid: number) {
-  try {
-    process.kill(pid, 0)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function stripAnsi(value: string) {
-  return value.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
-}
-
-function elapsed(started: number) {
-  return round(performance.now() - started)
-}
-
-function round(value: number) {
-  return Math.round(value * 100) / 100
-}
@@ -1,17 +0,0 @@
-import { defineConfig } from "@playwright/test"
-
-process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(/[:.]/g, "-")}-${process.pid}`
-
-export default defineConfig({
-  testDir: ".",
-  testMatch: "desktop-startup-benchmark.spec.ts",
-  outputDir: "../../test-results/performance-devex",
-  timeout: 15 * 60_000,
-  expect: {
-    timeout: 120_000,
-  },
-  fullyParallel: false,
-  workers: 1,
-  reporter: [["html", { outputFolder: "../../playwright-report/performance-devex", open: "never" }], ["line"]],
-  projects: [{ name: "desktop" }],
-})
@@ -7,7 +7,7 @@ process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(
 export default {
  ...config,
  testDir: ".",
-  testIgnore: ["unit/**", "devex/**"],
+  testIgnore: "unit/**",
  outputDir: "../test-results/performance",
  fullyParallel: false,
  workers: 1,
@@ -179,7 +179,7 @@ test.describe("timeline adverse visual stability", () => {
        userMessage(),
        assistantMessage([
          shell(shellID, "completed", wideLines(15)),
-          toolPart(contextIDs[0]!, "read", "completed", { path: "src/a.ts" }),
+          toolPart(contextIDs[0]!, "read", "completed", { filePath: "src/a.ts" }),
          toolPart(contextIDs[1]!, "glob", "completed", { path: ".", pattern: "**/*.ts" }),
          textPart(followingID, "Following responsive timeline content that wraps on narrow screens."),
        ]),
@@ -1,5 +1,4 @@
 import { test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
 import {
  defineVisualRegions,
  reportVisualStability,
@@ -19,20 +18,16 @@ import {
 } from "./fixture"

 const profiles = [
-  {
-    name: "edit",
-    tool: "edit",
-    input: { path: "src/edit.ts", oldString: "export const value = 1", newString: "export const value = 2" },
-  },
+  { name: "edit", tool: "edit", input: { filePath: "src/edit.ts" } },
  {
    name: "multi patch",
-    tool: "patch",
-    input: { patchText: "Update generated files" },
+    tool: "apply_patch",
+    input: { files: ["src/a.ts", "src/b.ts", "src/old.ts", "src/moved.ts"] },
  },
 ] as const

 for (const profile of profiles) {
-  test(`stabilizes ${profile.name} streaming to completed`, async ({ page }, testInfo) => {
+  test(`stabilizes ${profile.name} pending to completed`, async ({ page }, testInfo) => {
    const partID = `prt_file_matrix_${profiles.indexOf(profile)}`
    const followingID = `prt_file_matrix_following_${profiles.indexOf(profile)}`
    const timeline = await setupTimeline(page, {
@@ -40,7 +35,7 @@ for (const profile of profiles) {
        userMessage(),
        assistantMessage(
          [
-            toolPart(partID, profile.tool, "streaming", profile.input),
+            toolPart(partID, profile.tool, "pending", profile.input),
            textPart(followingID, `Following ${profile.name}`),
          ],
          { completed: false },
@@ -94,27 +89,34 @@ function completedPart(partID: string, profile: (typeof profiles)[number]) {
  if (profile.tool === "edit") {
    return toolPart(partID, profile.tool, "completed", profile.input, {
      metadata: {
-        files: [patchFile("src/edit.ts", "modified", 50)],
+        filediff: {
+          file: "src/edit.ts",
+          additions: 50,
+          deletions: 50,
+          before: source(50, false),
+          after: source(50, true),
+        },
      },
    })
  }
  const files = [
-    patchFile("src/a.ts", "modified", 20),
-    patchFile("src/b.ts", "added", 20),
-    patchFile("src/old.ts", "deleted", 20),
+    patchFile("src/a.ts", "update"),
+    patchFile("src/b.ts", "add"),
+    patchFile("src/old.ts", "delete"),
+    { ...patchFile("src/moved.ts", "move"), move: "src/new-place.ts" },
  ]
  return toolPart(partID, profile.tool, "completed", profile.input, { metadata: { files } })
 }

-function patchFile(file: string, status: "added" | "modified" | "deleted", lines: number) {
-  const before = status === "added" ? "" : source(lines, false)
-  const after = status === "deleted" ? "" : source(lines, true)
+function patchFile(filePath: string, type: "add" | "update" | "delete" | "move") {
  return {
-    file,
-    status,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
-    additions: status === "deleted" ? 0 : lines,
-    deletions: status === "added" ? 0 : lines,
+    filePath,
+    relativePath: filePath,
+    type,
+    additions: type === "delete" ? 0 : 20,
+    deletions: type === "add" ? 0 : 20,
+    before: type === "add" ? undefined : source(20, false),
+    after: type === "delete" ? undefined : source(20, true),
  }
 }

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
 import {
  defineVisualRegions,
  reportVisualStability,
@@ -21,13 +20,13 @@ import {
 test("adds patch files incrementally without resetting outer expansion", async ({ page }, testInfo) => {
  const patchID = "prt_incremental_01_patch"
  const followingID = "prt_incremental_02_following"
-  const first = patchFile("src/a.ts", "modified")
+  const first = patchFile("src/a.ts", "update")
  const timeline = await setupTimeline(page, {
    messages: [
      userMessage(),
      assistantMessage(
        [
-          toolPart(patchID, "patch", "running", { patchText: "Update files" }, { metadata: { files: [first] } }),
+          toolPart(patchID, "apply_patch", "running", { files: [first.filePath] }, { metadata: { files: [first] } }),
          textPart(followingID, "Following incremental patch"),
        ],
        { completed: false },
@@ -56,15 +55,15 @@ test("adds patch files incrementally without resetting outer expansion", async (
    },
  })
  await startVisualProbe(page, regions)
-  const second = patchFile("src/b.ts", "added")
-  const third = patchFile("src/old.ts", "deleted")
+  const second = patchFile("src/b.ts", "add")
+  const third = patchFile("src/old.ts", "delete")
  await timeline.send(
    partUpdated(
      toolPart(
        patchID,
-        "patch",
+        "apply_patch",
        "running",
-        { patchText: "Update files" },
+        { files: [first.filePath, second.filePath] },
        { metadata: { files: [first, second] } },
      ),
    ),
@@ -74,9 +73,9 @@ test("adds patch files incrementally without resetting outer expansion", async (
    partUpdated(
      toolPart(
        patchID,
-        "patch",
+        "apply_patch",
        "completed",
-        { patchText: "Update files" },
+        { files: [first.filePath, second.filePath, third.filePath] },
        { metadata: { files: [first, second, third] } },
      ),
    ),
@@ -107,15 +106,15 @@ test("adds patch files incrementally without resetting outer expansion", async (
  await expect(page.locator('[data-scope="apply-patch"] [data-type="delete"]')).toBeVisible()
 })

-function patchFile(file: string, status: "added" | "modified" | "deleted") {
-  const before = status === "added" ? "" : source(false)
-  const after = status === "deleted" ? "" : source(true)
+function patchFile(filePath: string, type: "add" | "update" | "delete") {
  return {
-    file,
-    status,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
-    additions: status === "deleted" ? 0 : 4,
-    deletions: status === "added" ? 0 : 3,
+    filePath,
+    relativePath: filePath,
+    type,
+    additions: type === "delete" ? 0 : 4,
+    deletions: type === "add" ? 0 : 3,
+    before: type === "add" ? undefined : source(false),
+    after: type === "delete" ? undefined : source(true),
  }
 }

@@ -35,7 +35,7 @@ describe("timeline fixture validation", () => {
        userMessage(),
        {
          ...assistantMessage(),
-          content: [{ type: "tool", id: "call_invalid", name: "shell", state: { status: "completed" } }],
+          content: [{ type: "tool", id: "call_invalid", name: "bash", state: { status: "completed" } }],
        } as never,
      ]),
    ).toThrow()
@@ -60,11 +60,12 @@ if (false) {
  const userSeed = { id: "prt_type_user", type: "text", text: "typed" } satisfies PartSeed<"user">
  userMessage([userSeed])

-  // @ts-expect-error Tool completion fields are not valid while streaming.
-  toolPart("prt_invalid_streaming", "shell", "streaming", {}, { output: "impossible" })
-  toolPart("prt_valid_running", "shell", "running", {}, { output: "progressive output" })
+  // @ts-expect-error Tool completion fields are not valid while pending.
+  toolPart("prt_invalid_pending", "bash", "pending", {}, { output: "impossible" })
+  // @ts-expect-error Tool completion fields are not valid while running.
+  toolPart("prt_invalid_running", "bash", "running", {}, { output: "impossible" })
  // @ts-expect-error Tool error fields are not valid after completion.
-  toolPart("prt_invalid_completed", "shell", "completed", {}, { error: "impossible" })
+  toolPart("prt_invalid_completed", "bash", "completed", {}, { error: "impossible" })

  assistantMessage([
    // @ts-expect-error Agent references belong to user messages, not assistant messages.
@@ -60,17 +60,17 @@ type ReasoningSeed = {
 type ToolSeed = {
  id: string
  type: "tool"
-  name: string
+  callID: string
+  tool: string
  messageID?: string
  executed?: boolean
  providerState?: Record<string, unknown>
  providerResultState?: Record<string, unknown>
  state:
-    | { status: "streaming"; input: Record<string, unknown>; raw: string }
+    | { status: "pending"; input: Record<string, unknown>; raw: string }
    | {
        status: "running"
        input: Record<string, unknown>
-        output?: string
        title?: string
        metadata: Record<string, unknown>
        time: { start: number }
@@ -100,10 +100,10 @@ export type PartSeed<Owner extends "user" | "assistant"> = Owner extends "user"
  ? TextSeed | FileSeed | AgentSeed
  : TextSeed | ReasoningSeed | ToolSeed

-type ToolOptions<State extends ToolStatus> = State extends "streaming"
+type ToolOptions<State extends ToolStatus> = State extends "pending"
  ? { output?: never; title?: never; metadata?: never; error?: never }
  : State extends "running"
-    ? { title?: string; metadata?: Record<string, unknown>; output?: string; error?: never }
+    ? { title?: string; metadata?: Record<string, unknown>; output?: never; error?: never }
    : State extends "error"
      ? { error?: string; metadata?: Record<string, unknown>; output?: never; title?: never }
      : { output?: string; title?: string; metadata?: Record<string, unknown>; error?: never }
@@ -371,15 +371,6 @@ export function partUpdated(part: PartSeed<"assistant">): readonly OpenCodeEvent
  }
  if (part.type === "reasoning") {
    startedParts.add(part.id)
-    if (!started && !part.text)
-      return [
-        makeEvent("session.reasoning.started", {
-          sessionID,
-          assistantMessageID: messageID,
-          ordinal: ref.ordinal!,
-          state: jsonRecord(part.metadata),
-        }),
-      ]
    return [
      ...(started
        ? []
@@ -551,9 +542,9 @@ export function reasoningPart(id: string, text: string): ReasoningSeed {
 export function toolPart(
  id: string,
  tool: string,
-  state: "streaming",
+  state: "pending",
  input: Record<string, unknown>,
-  options?: ToolOptions<"streaming">,
+  options?: ToolOptions<"pending">,
 ): ToolSeed
 export function toolPart(
  id: string,
@@ -583,15 +574,14 @@ export function toolPart(
  input: Record<string, unknown>,
  options: ToolOptions<ToolStatus> = {},
 ): ToolSeed {
-  const base = { id, type: "tool" as const, name: tool }
-  if (state === "streaming") return { ...base, state: { status: state, input, raw: "" } }
+  const base = { id, type: "tool" as const, callID: id, tool }
+  if (state === "pending") return { ...base, state: { status: state, input, raw: "" } }
  if (state === "running")
    return {
      ...base,
      state: {
        status: state,
        input,
-        ...(options.output === undefined ? {} : { output: options.output }),
        title: options.title,
        metadata: options.metadata ?? {},
        time: { start: 1700000001000 },
@@ -622,10 +612,12 @@ export function toolPart(
 }

 export function shell(id: string, state: ToolStatus, output = "", command = `echo ${id}`): ToolSeed {
-  if (state === "streaming") return toolPart(id, "shell", state, { command })
-  if (state === "running") return toolPart(id, "shell", state, { command }, { title: command, output })
-  if (state === "error") return toolPart(id, "shell", state, { command }, { error: output || undefined })
-  return toolPart(id, "shell", state, { command }, { title: command, output })
+  if (state === "pending") return toolPart(id, "bash", state, { command })
+  if (state === "running")
+    return toolPart(id, "bash", state, { command }, { title: command, metadata: { command, output } })
+  if (state === "error")
+    return toolPart(id, "bash", state, { command }, { error: output || undefined, metadata: { command, output } })
+  return toolPart(id, "bash", state, { command }, { title: command, output, metadata: { command, output } })
 }

 export function completedAssistantInfo(info: SessionMessageAssistant): SessionMessageAssistant {
@@ -663,7 +655,7 @@ function messageContent(
 ): SessionMessageAssistant["content"][number] {
  if (part.type === "tool") {
    partRefs.set(part.id, { messageID, type: part.type })
-    toolStates.set(part.id, part.state.status)
+    toolStates.set(part.callID, part.state.status)
  } else {
    partRefs.set(part.id, { messageID, type: part.type, ordinal: ordinals[part.type]++ })
    startedParts.add(part.id)
@@ -683,8 +675,8 @@ function messageContent(
  const completed = state.status === "completed" || state.status === "error" ? state.time.end : undefined
  const base = {
    type: "tool" as const,
-    id: part.id,
-    name: part.name,
+    id: part.callID,
+    name: part.tool,
    time: {
      created: time?.start ?? 1700000001000,
      ...(time?.start === undefined ? {} : { ran: time.start }),
@@ -694,18 +686,11 @@ function messageContent(
    ...(part.providerState ? { providerState: jsonRecord(part.providerState) } : {}),
    ...(part.providerResultState ? { providerResultState: jsonRecord(part.providerResultState) } : {}),
  }
-  if (state.status === "streaming") return { ...base, state: { status: "streaming", input: state.raw } }
+  if (state.status === "pending") return { ...base, state: { status: "streaming", input: state.raw } }
  if (state.status === "running")
    return {
      ...base,
-      state: {
-        status: "running",
-        input: jsonRecord(state.input),
-        metadata: jsonRecord({
-          ...state.metadata,
-          ...(state.output === undefined ? {} : { output: state.output }),
-        }),
-      },
+      state: { status: "running", input: jsonRecord(state.input), metadata: jsonRecord(state.metadata) },
    }
  if (state.status === "error")
    return {
@@ -729,7 +714,7 @@ function messageContent(
 }

 function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[] {
-  const previous = toolStates.get(part.id)
+  const previous = toolStates.get(part.callID)
  if (previous === "completed" || previous === "error") return []

  const events: OpenCodeEvent[] = []
@@ -738,27 +723,27 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
      makeEvent("session.tool.input.started", {
        sessionID,
        assistantMessageID: messageID,
-        id: part.id,
-        name: part.name,
+        id: part.callID,
+        name: part.tool,
      }),
    )
  }
-  if (part.state.status === "streaming") {
-    toolStates.set(part.id, part.state.status)
+  if (part.state.status === "pending") {
+    toolStates.set(part.callID, part.state.status)
    return events
  }
-  if (!previous || previous === "streaming") {
+  if (!previous || previous === "pending") {
    events.push(
      makeEvent("session.tool.input.ended", {
        sessionID,
        assistantMessageID: messageID,
-        id: part.id,
+        id: part.callID,
        text: JSON.stringify(part.state.input),
      }),
      makeEvent("session.tool.called", {
        sessionID,
        assistantMessageID: messageID,
-        id: part.id,
+        id: part.callID,
        input: part.state.input,
        executed: part.executed ?? true,
        state: jsonRecord(part.providerState),
@@ -766,20 +751,16 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
    )
  }
  if (part.state.status === "running") {
-    const metadata = {
-      ...part.state.metadata,
-      ...(part.state.output === undefined ? {} : { output: part.state.output }),
-    }
-    if (previous === "running" || Object.keys(metadata).length)
+    if (previous === "running" || Object.keys(part.state.metadata).length)
      events.push(
        makeEvent("session.tool.progress", {
          sessionID,
          assistantMessageID: messageID,
-          id: part.id,
-          metadata: jsonRecord(metadata),
+          id: part.callID,
+          metadata: jsonRecord(part.state.metadata),
        }),
      )
-    toolStates.set(part.id, part.state.status)
+    toolStates.set(part.callID, part.state.status)
    return events
  }
  if (part.state.status === "error") {
@@ -787,28 +768,28 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
      makeEvent("session.tool.failed", {
        sessionID,
        assistantMessageID: messageID,
-        id: part.id,
+        id: part.callID,
        error: { type: "ToolError", message: part.state.error },
        metadata: jsonRecord(part.state.metadata),
        executed: part.executed ?? true,
        resultState: jsonRecord(part.providerResultState),
      }),
    )
-    toolStates.set(part.id, part.state.status)
+    toolStates.set(part.callID, part.state.status)
    return events
  }
  events.push(
    makeEvent("session.tool.success", {
      sessionID,
      assistantMessageID: messageID,
-      id: part.id,
+      id: part.callID,
      content: [{ type: "text", text: part.state.output }],
      metadata: jsonRecord(part.state.metadata),
      executed: part.executed ?? true,
      resultState: jsonRecord(part.providerResultState),
    }),
  )
-  toolStates.set(part.id, part.state.status)
+  toolStates.set(part.callID, part.state.status)
  return events
 }

@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
 import {
  defineVisualRegions,
  reportVisualStability,
@@ -59,14 +58,14 @@ test("expands and collapses a long completed shell without overlap", async ({ pa
  await startVisualProbe(page, regions)
  await trigger.click()
  await expect(trigger).toHaveAttribute("aria-expanded", "true")
-  await waitForVisualSettle(page, [regions.shell.selector, regions.following.selector])
+  await page.waitForTimeout(500)
  const expanded = await stopVisualProbe<keyof typeof regions>(page)
  await reportVisualStability(testInfo, "shell-expand", expanded, plan)

  await startVisualProbe(page, regions)
  await trigger.click()
  await expect(trigger).toHaveAttribute("aria-expanded", "false")
-  await waitForVisualSettle(page, [regions.shell.selector, regions.following.selector])
+  await page.waitForTimeout(500)
  const collapsed = await stopVisualProbe<keyof typeof regions>(page)
  await reportVisualStability(testInfo, "shell-collapse", collapsed, plan)
 })
@@ -84,7 +83,7 @@ test("expands and collapses a completed context group without overlap", async ({
    messages: [
      userMessage(),
      assistantMessage([
-        toolPart(ids[0]!, "read", "completed", { path: "src/a.ts" }),
+        toolPart(ids[0]!, "read", "completed", { filePath: "src/a.ts" }),
        toolPart(ids[1]!, "glob", "completed", { path: ".", pattern: "**/*.ts" }),
        toolPart(ids[2]!, "grep", "completed", { path: ".", pattern: "stable" }),
        toolPart(ids[3]!, "list", "completed", { path: "src" }),
@@ -111,7 +110,7 @@ test("expands and collapses a completed context group without overlap", async ({
    await startVisualProbe(page, regions)
    await trigger.click()
    await expect(trigger).toHaveAttribute("aria-expanded", String(expanded))
-    await waitForVisualSettle(page, [regions.context.selector, regions.following.selector])
+    await page.waitForTimeout(500)
    const trace = await stopVisualProbe<keyof typeof regions>(page)
    await reportVisualStability(
      testInfo,
@@ -143,23 +142,16 @@ test("expands and collapses an edit diff without moving twice", async ({ page },
          editID,
          "edit",
          "completed",
-          { path: "src/edit.ts", oldString: "export const value = 1", newString: "export const value = 2" },
+          { filePath: "src/edit.ts" },
          {
            metadata: {
-              files: [
-                {
-                  file: "src/edit.ts",
-                  patch: createTwoFilesPatch(
-                    "a/src/edit.ts",
-                    "b/src/edit.ts",
-                    source(40, false),
-                    source(40, true),
-                  ),
-                  additions: 40,
-                  deletions: 40,
-                  status: "modified",
-                },
-              ],
+              filediff: {
+                file: "src/edit.ts",
+                additions: 40,
+                deletions: 40,
+                before: source(40, false),
+                after: source(40, true),
+              },
            },
          },
        ),
@@ -190,7 +182,7 @@ test("expands and collapses an edit diff without moving twice", async ({ page },
  await startVisualProbe(page, regions)
  await trigger.click()
  await expect(trigger).toHaveAttribute("aria-expanded", "true")
-  await waitForVisualSettle(page, [regions.edit.selector, regions.following.selector])
+  await page.waitForTimeout(900)
  const trace = await stopVisualProbe<keyof typeof regions>(page)
  await reportVisualStability(
    testInfo,
@@ -17,32 +17,32 @@ import {
  userMessage,
 } from "./fixture"

-test("adds a subagent child-session link without replacing the row", async ({ page }, testInfo) => {
-  const taskID = "prt_subagent_link"
-  const childID = "ses_subagent_child"
-  const input = { description: "Inspect child", agent: "explore", prompt: "Inspect the child Session." }
+test("adds a task child-session link without replacing the task row", async ({ page }, testInfo) => {
+  const taskID = "prt_task_link"
+  const childID = "ses_task_child"
+  const input = { description: "Inspect child", subagent_type: "explore" }
  const timeline = await setupTimeline(page, {
-    messages: [userMessage(), assistantMessage([toolPart(taskID, "subagent", "running", input)], { completed: false })],
+    messages: [userMessage(), assistantMessage([toolPart(taskID, "task", "running", input)], { completed: false })],
    sessions: [session(), session({ id: childID, parentID: sessionID, title: "Inspect child" })],
    cpuRate: 4,
  })
  const regions = defineVisualRegions({
-    subagent: { selector: `[data-timeline-part-id="${renderedPartID(taskID)}"] [data-slot="collapsible-trigger"]` },
+    task: { selector: `[data-timeline-part-id="${renderedPartID(taskID)}"] [data-slot="collapsible-trigger"]` },
  })
  await startVisualProbe(page, regions)
  await timeline.send(
-    partUpdated(toolPart(taskID, "subagent", "completed", input, { metadata: { sessionID: childID } })),
+    partUpdated(toolPart(taskID, "task", "completed", input, { metadata: { sessionId: childID } })),
    500,
  )
  const trace = await stopVisualProbe<keyof typeof regions>(page)
  await reportVisualStability(
    testInfo,
-    "subagent-link",
+    "task-link",
    trace,
    visualPlan(regions, [
-      { type: "required", regions: ["subagent"] },
-      { type: "unique", regions: ["subagent"] },
-      { type: "stable", regions: ["subagent"] },
+      { type: "required", regions: ["task"] },
+      { type: "unique", regions: ["task"] },
+      { type: "stable", regions: ["task"] },
      { type: "opacity", regions: "all" },
      { type: "continuity", regions: "all" },
      { type: "motion", regions: "all", maxPositionReversals: 0 },
@@ -21,30 +21,24 @@ import {
 } from "./fixture"

 test.describe("timeline tool state stability", () => {
-  test("moves lightweight tools through streaming, running, and completed without replacing rows", async ({
+  test("moves lightweight tools through pending, running, and completed without replacing rows", async ({
    page,
  }, testInfo) => {
-    const ids = ["webfetch", "websearch", "subagent", "skill", "custom"] as const
+    const ids = ["webfetch", "websearch", "task", "skill", "custom"] as const
    const inputs = {
      webfetch: { url: "https://example.com/docs" },
      websearch: { query: "timeline stability" },
-      subagent: { description: "Inspect timeline", agent: "explore", prompt: "Inspect the timeline." },
+      task: { description: "Inspect timeline", subagent_type: "explore" },
      skill: { name: "stability" },
      custom: { target: "timeline", depth: 2 },
    }
-    const names = {
-      webfetch: "webfetch",
-      websearch: "websearch",
-      subagent: "subagent",
-      skill: "skill",
-      custom: "mcp_probe",
-    }
+    const names = { webfetch: "webfetch", websearch: "websearch", task: "task", skill: "skill", custom: "mcp_probe" }
    const questionID = "prt_state_question"
    const todoID = "prt_state_todo"
    const initial = [
-      ...ids.map((id) => toolPart(`prt_state_${id}`, names[id], "streaming", inputs[id])),
-      toolPart(questionID, "question", "streaming", questionInput()),
-      toolPart(todoID, "todowrite", "streaming", { todos: [{ content: "Hidden", status: "pending" }] }),
+      ...ids.map((id) => toolPart(`prt_state_${id}`, names[id], "pending", inputs[id])),
+      toolPart(questionID, "question", "pending", questionInput()),
+      toolPart(todoID, "todowrite", "pending", { todos: [{ content: "Hidden", status: "pending" }] }),
      textPart("prt_state_following", "Following lightweight tools"),
    ]
    const childID = "ses_timeline_child"
@@ -61,14 +55,14 @@ test.describe("timeline tool state stability", () => {
    const regionIDs = [
      "prt_state_webfetch",
      "prt_state_websearch",
-      "prt_state_subagent",
+      "prt_state_task",
      "prt_state_skill",
      "prt_state_custom",
    ] as const
    const regions = defineVisualRegions({
      prt_state_webfetch: toolRegion(regionIDs[0]),
      prt_state_websearch: toolRegion(regionIDs[1]),
-      prt_state_subagent: toolRegion(regionIDs[2]),
+      prt_state_task: toolRegion(regionIDs[2]),
      prt_state_skill: toolRegion(regionIDs[3]),
      prt_state_custom: toolRegion(regionIDs[4]),
    })
@@ -79,9 +73,9 @@ test.describe("timeline tool state stability", () => {
        [80, 240, 100, 360, 140][index],
      )
    }
-    for (const [index, id] of ["skill", "webfetch", "custom", "subagent", "websearch"].entries()) {
+    for (const [index, id] of ["skill", "webfetch", "custom", "task", "websearch"].entries()) {
      const key = id as (typeof ids)[number]
-      const metadata = key === "subagent" ? { sessionID: childID } : key === "websearch" ? { provider: "exa" } : {}
+      const metadata = key === "task" ? { sessionId: childID } : key === "websearch" ? { provider: "exa" } : {}
      const output = key === "websearch" ? "Result https://example.com/result" : "Completed"
      await timeline.send(
        partUpdated(toolPart(`prt_state_${key}`, names[key], "completed", inputs[key], { metadata, output })),
@@ -127,12 +121,12 @@ test.describe("timeline tool state stability", () => {
    const ids = ["prt_ctx_01_read", "prt_ctx_02_glob", "prt_ctx_03_grep", "prt_ctx_04_list"]
    const tools = ["read", "glob", "grep", "list"]
    const inputs = [
-      { path: "src/a.ts", offset: 0, limit: 120 },
+      { filePath: "src/a.ts", offset: 0, limit: 120 },
      { path: directory, pattern: "**/*.ts" },
      { path: directory, pattern: "stability", include: "*.ts" },
      { path: "src" },
    ]
-    const context = ids.map((id, index) => toolPart(id, tools[index]!, "streaming", inputs[index]!))
+    const context = ids.map((id, index) => toolPart(id, tools[index]!, "pending", inputs[index]!))
    const timeline = await setupTimeline(page, {
      messages: [
        userMessage(),
@@ -11,7 +11,7 @@ import {
 } from "./timeline-test-helpers"
 import { waitForStableTimeline } from "./session-tab-switch-probe"

-const contentSelector = '[data-message-id], [data-component="composer-editor"]'
+const contentSelector = '[data-message-id], [data-component="prompt-input"]'
 const draftID = "draft_first_navigation"

 benchmark.describe("performance: first navigation paint", () => {
@@ -41,11 +41,11 @@ benchmark.describe("performance: first navigation paint", () => {
      href,
      destinationPath: href,
      sourceSelector: messageSelector(fixture.expected.sourceMessageIDs.at(-1)!),
-      destinationSelector: '[data-component="composer-editor"]',
+      destinationSelector: '[data-component="prompt-input"]',
      contentSelector,
      navigate: async () => {
        await page.locator(`[data-slot="titlebar-tabs"] a[href="${href}"]`).first().click()
-        await expect(page.locator('[data-component="composer-editor"]')).toBeVisible()
+        await expect(page.locator('[data-component="prompt-input"]')).toBeVisible()
      },
    })
    report(result)
@@ -4,7 +4,6 @@ import type { Page } from "@playwright/test"
 import { mockOpenCodeServer } from "../../utils/mock-server"
 import { expectAppVisible, expectSessionTitle } from "../../utils/waits"
 import { expect } from "../benchmark"
-import { createTwoFilesPatch } from "diff"

 const directory = "C:/OpenCode/TimelineStateRegression"
 const projectID = "proj_timeline_state_regression"
@@ -27,29 +26,28 @@ const userMessage = {

 const editPart: ToolSeed = {
  id: editPartID,
+  sessionID,
+  messageID: assistantMessageID,
  type: "tool",
-  name: "edit",
+  callID: "call_edit_regression",
+  tool: "edit",
  state: {
    status: "completed",
-    input: {
-      path: "src/regression.ts",
-      oldString: "export const value = 'before'",
-      newString: "export const value = 'after'",
-    },
-    content: [{ type: "text", text: "Edited src/regression.ts" }],
+    input: { filePath: "src/regression.ts" },
+    output: "Edited src/regression.ts",
+    title: "src/regression.ts",
    metadata: {
-      files: [
-        currentFile(
-          "src/regression.ts",
-          "export const value = 'before'\n",
-          "export const value = 'after'\n",
-          1,
-          1,
-        ),
-      ],
+      filediff: {
+        file: "src/regression.ts",
+        additions: 1,
+        deletions: 1,
+        before: "export const value = 'before'\n",
+        after: "export const value = 'after'\n",
+      },
+      diff: "diff --git a/src/regression.ts b/src/regression.ts\n-export const value = 'before'\n+export const value = 'after'\n",
    },
+    time: { start: 1700000001000, end: 1700000002000 },
  },
-  time: { created: 1700000001000, ran: 1700000001000, completed: 1700000002000 },
 }

 const assistantMessage = {
@@ -206,20 +204,20 @@ function performanceTurn(index: number) {
      ? [
          {
            id: `prt_0000_${suffix}_edit`,
+            sessionID,
+            messageID: assistantID,
            type: "tool",
-            name: "edit",
+            callID: `call_0000_${suffix}_edit`,
+            tool: "edit",
            state: {
              status: "completed",
-              input: { path: `src/history-${index}.ts`, oldString: before, newString: after },
-              content: [{ type: "text", text: `Edited src/history-${index}.ts` }],
+              input: { filePath: `src/history-${index}.ts` },
+              output: `Edited src/history-${index}.ts`,
+              title: `src/history-${index}.ts`,
              metadata: {
-                files: [currentFile(`src/history-${index}.ts`, before, after, 48, 48)],
+                filediff: { file: `src/history-${index}.ts`, additions: 48, deletions: 48, before, after },
              },
-            },
-            time: {
-              created: 1690000001200 + index * 2_000,
-              ran: 1690000001200 + index * 2_000,
-              completed: 1690000001400 + index * 2_000,
+              time: { start: 1690000001200 + index * 2_000, end: 1690000001400 + index * 2_000 },
            },
          },
        ]
@@ -228,18 +226,20 @@ function performanceTurn(index: number) {
      ? [
          {
            id: `prt_0000_${suffix}_write`,
+            sessionID,
+            messageID: assistantID,
            type: "tool",
-            name: "write",
+            callID: `call_0000_${suffix}_write`,
+            tool: "write",
            state: {
              status: "completed",
-              input: { path: `src/generated-${index}.tsx`, content: after },
-              content: [{ type: "text", text: `Wrote src/generated-${index}.tsx` }],
-              metadata: { files: [currentFile(`src/generated-${index}.tsx`, "", after, 32, 0)] },
-            },
-            time: {
-              created: 1690000001400 + index * 2_000,
-              ran: 1690000001400 + index * 2_000,
-              completed: 1690000001500 + index * 2_000,
+              input: { filePath: `src/generated-${index}.tsx`, content: after },
+              output: `Wrote src/generated-${index}.tsx`,
+              title: `src/generated-${index}.tsx`,
+              metadata: {
+                filediff: { file: `src/generated-${index}.tsx`, additions: 32, deletions: 0, before: "", after },
+              },
+              time: { start: 1690000001400 + index * 2_000, end: 1690000001500 + index * 2_000 },
            },
          },
        ]
@@ -248,24 +248,31 @@ function performanceTurn(index: number) {
      ? [
          {
            id: `prt_0000_${suffix}_patch`,
+            sessionID,
+            messageID: assistantID,
            type: "tool",
-            name: "patch",
+            callID: `call_0000_${suffix}_patch`,
+            tool: "apply_patch",
            state: {
              status: "completed",
              input: { patchText: realisticPatch(index) },
-              content: [{ type: "text", text: "Success. Updated src/components/SessionCard.tsx" }],
+              output: "Success. Updated src/components/SessionCard.tsx",
+              title: "src/components/SessionCard.tsx",
              metadata: {
                files: [
                  {
-                    ...currentFile("src/components/SessionCard.tsx", before, after, 8, 3),
+                    filePath: "src/components/SessionCard.tsx",
+                    relativePath: "src/components/SessionCard.tsx",
+                    type: "update",
+                    additions: 8,
+                    deletions: 3,
+                    patch: realisticPatch(index),
+                    before,
+                    after,
                  },
                ],
              },
-            },
-            time: {
-              created: 1690000001500 + index * 2_000,
-              ran: 1690000001500 + index * 2_000,
-              completed: 1690000001700 + index * 2_000,
+              time: { start: 1690000001500 + index * 2_000, end: 1690000001700 + index * 2_000 },
            },
          },
        ]
@@ -302,16 +309,20 @@ function performanceTurn(index: number) {
 }

 type ToolSeed = {
-  id: string
+  id?: string
+  sessionID?: string
+  messageID?: string
  type: "tool"
-  name: string
+  callID: string
+  tool: string
  state: {
-    status: "completed"
+    status: string
    input: Record<string, unknown>
-    content: [{ type: "text"; text: string }]
+    output: string
+    title?: string
    metadata: Record<string, unknown>
+    time: { start: number; end: number }
  }
-  time: { created: number; ran: number; completed: number }
 }

 type ContentSeedBase = { id?: string; sessionID?: string; messageID?: string }
@@ -324,13 +335,13 @@ type ContentSeed =
 function toolContent(part: ToolSeed): SessionMessageAssistant["content"][number] {
  return {
    type: "tool",
-    id: part.id,
-    name: part.name,
-    time: part.time,
+    id: part.callID,
+    name: part.tool,
+    time: { created: part.state.time.start, ran: part.state.time.start, completed: part.state.time.end },
    state: {
      status: "completed",
      input: part.state.input as Record<string, JsonValue>,
-      content: part.state.content,
+      content: [{ type: "text", text: part.state.output }],
      metadata: part.state.metadata as Record<string, JsonValue>,
    },
  }
@@ -411,16 +422,6 @@ export function MessageSummary(props: { messages: Message[]; locale: string }) {
 `
 }

-function currentFile(file: string, before: string, after: string, additions: number, deletions: number) {
-  return {
-    file,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
-    additions,
-    deletions,
-    status: before ? (after ? "modified" : "deleted") : "added",
-  }
-}
-
 function realisticPatch(index: number) {
  return `*** Begin Patch
 *** Update File: src/components/SessionCard.tsx
@@ -1,6 +1,4 @@
 import type { CDPSession, Page } from "@playwright/test"
-import path from "node:path"
-import { mkdir, writeFile } from "node:fs/promises"

 export async function startTimelineProfile(page: Page, options: { cpuThrottle: number; profileCPU: boolean }) {
  const cdp = await page.context().newCDPSession(page)
@@ -14,13 +12,6 @@ export async function startTimelineProfile(page: Page, options: { cpuThrottle: n
    async stop() {
      if (!options.profileCPU) return
      const result = await cdp.send("Profiler.stop")
-      const directory = process.env.TIMELINE_CPU_PROFILE_DIR
-      if (directory) {
-        await mkdir(directory, { recursive: true })
-        const file = path.join(directory, `${process.env.OPENCODE_PERFORMANCE_RUN_ID ?? "manual"}-timeline.cpuprofile`)
-        await writeFile(file, JSON.stringify(result.profile))
-        console.log("timeline cpu profile file", file)
-      }
      const self = new Map<number, number>()
      result.profile.samples?.forEach((id, index) => {
        const duration = (result.profile.timeDeltas?.[index] ?? 0) / 1_000
@@ -1,5 +1,3 @@
-import { createTwoFilesPatch } from "diff"
-
 const words = [
  "alpha",
  "bravo",
@@ -30,21 +28,22 @@ const directory = "C:/OpenCode/SmokeProject"
 const projectID = "proj_smoke_timeline"
 const model = { providerID: "opencode", modelID: "claude-opus-4-6", variant: "max" }

-type MessagePart =
-  | { id: string; type: "text"; text: string }
-  | { id: string; type: "reasoning"; text: string; time?: { start: number; end?: number } }
-  | {
-      id: string
-      type: "tool"
-      name: string
-      state: {
-        status: "completed"
-        input: Record<string, unknown>
-        content: [{ type: "text"; text: string }]
-        metadata: Record<string, unknown>
-      }
-      time: { created: number; ran: number; completed: number }
-    }
+type MessagePart = {
+  id: string
+  type: "text" | "reasoning" | "tool"
+  text?: string
+  time?: { start: number; end?: number }
+  callID?: string
+  tool?: string
+  state?: {
+    status: "completed"
+    input: Record<string, unknown>
+    output: string
+    title: unknown
+    metadata: Record<string, unknown>
+    time: { start: number; end: number }
+  }
+}

 function lorem(seed: number, length: number) {
  let out = ""
@@ -103,16 +102,17 @@ function messageContent(part: MessagePart): SessionMessageAssistant["content"][n
        ? { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) }
        : undefined,
    }
+  const state = part.state!
  return {
    type: "tool",
-    id: part.id,
-    name: part.name,
-    time: part.time,
+    id: part.callID ?? part.id,
+    name: part.tool!,
+    time: { created: state.time.start, ran: state.time.start, completed: state.time.end },
    state: {
      status: "completed",
-      input: part.state.input as Record<string, JsonValue>,
-      content: part.state.content,
-      metadata: part.state.metadata as Record<string, JsonValue>,
+      input: state.input as Record<string, JsonValue>,
+      content: [{ type: "text", text: state.output }],
+      metadata: state.metadata as Record<string, JsonValue>,
    },
  }
 }
@@ -149,46 +149,43 @@ function toolPart(
 ): MessagePart {
  const metadata =
    metadataOverride ??
-    (tool === "patch"
-      ? {
-          files: [
-            patchFile(index, "modified"),
-            patchFile(index + 1, index % 2 === 0 ? "added" : "deleted"),
-          ],
-        }
+    (tool === "apply_patch"
+      ? { files: [patchFile(index, "update"), patchFile(index + 1, index % 2 === 0 ? "add" : "delete")] }
      : tool === "edit" || tool === "write"
-        ? { files: [fileDiff(String(input.path ?? `src/generated/file-${index}.ts`), index)] }
+        ? {
+            filediff: fileDiff(String(input.filePath ?? `src/generated/file-${index}.ts`), index),
+            diff: patch(index, outputLength),
+            preview: patch(index + 1, 420),
+          }
        : tool === "question"
          ? { answers: [["Proceed"], ["Keep sample output"]] }
          : {})
  return {
-    id: id(`call_${tool}_${partIndex}`, index),
+    id: id(`prt_tool_${tool}_${partIndex}`, index),
    type: "tool",
-    name: tool,
+    callID: id("call", index * 10 + partIndex),
+    tool,
    state: {
      status: "completed",
      input,
-      content: [{ type: "text", text: lorem(index * 23 + partIndex, outputLength) }],
+      output: lorem(index * 23 + partIndex, outputLength),
+      title: tool === "bash" ? "Verify generated output" : input.filePath || input.path || input.pattern || "completed",
      metadata,
-    },
-    time: {
-      created: 1700000000000 + index * 10_000,
-      ran: 1700000000000 + index * 10_000,
-      completed: 1700000000000 + index * 10_000 + 400,
+      time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
    },
  }
 }

-function patchFile(seed: number, status: "added" | "modified" | "deleted") {
-  const file = `src/generated/patch-${seed}.ts`
-  const before = status === "added" ? "" : code(seed, 18)
-  const after = status === "deleted" ? "" : code(seed + 1, 24)
+function patchFile(seed: number, type: "add" | "update" | "delete") {
  return {
-    file,
-    status,
-    additions: status === "deleted" ? 0 : (seed % 7) + 1,
-    deletions: status === "added" ? 0 : seed % 4,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    filePath: `src/generated/patch-${seed}.ts`,
+    relativePath: `src/generated/patch-${seed}.ts`,
+    type,
+    additions: (seed % 7) + 1,
+    deletions: type === "add" ? 0 : seed % 4,
+    patch: patch(seed, 520),
+    before: type === "add" ? undefined : code(seed, 18),
+    after: type === "delete" ? undefined : code(seed + 1, 24),
  }
 }

@@ -203,13 +200,17 @@ function fileDiff(file: string, seed: number) {
        : before.replace("value4", "updatedValue4").replace("value20", "updatedValue20")
  return {
    file,
-    status: "modified" as const,
    additions: lines === 300 ? 300 : lines === 2 ? 1 : 2,
    deletions: lines === 300 ? 300 : lines === 2 ? 1 : 2,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    before,
+    after,
  }
 }

+function patch(seed: number, length: number) {
+  return `diff --git a/src/generated/file-${seed}.ts b/src/generated/file-${seed}.ts\n+${lorem(seed, length).replace(/\n/g, "\n+")}`
+}
+
 function code(seed: number, lines: number, width = 32) {
  return Array.from(
    { length: lines },
@@ -224,24 +225,22 @@ function turn(index: number): SessionMessageInfo[] {
    ...(index % 5 === 0 ? [reasoningPart(index, 0, 420)] : []),
    ...(index % 3 === 0
      ? [
-          toolPart(index, 0, "read", { path: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
+          toolPart(index, 0, "read", { filePath: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
          toolPart(index, 5, "glob", { path: directory, pattern: `**/*sample-${index}*.ts` }, 140),
          toolPart(index, 1, "grep", { path: directory, pattern: `sample-${index}`, include: "*.ts" }, 180),
          toolPart(index, 6, "list", { path: `src/generated/${index}` }, 120),
        ]
      : []),
    textPart(index, 2, 160 + (index % 6) * 90),
-    ...(index % 4 === 0
-      ? [toolPart(index, 3, "edit", { path: `src/generated/file-${index}.ts`, oldString: "before", newString: "after" }, 700)]
-      : []),
+    ...(index % 4 === 0 ? [toolPart(index, 3, "edit", { filePath: `src/generated/file-${index}.ts` }, 700)] : []),
    ...(index % 6 === 0
-      ? [toolPart(index, 7, "write", { path: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
+      ? [toolPart(index, 7, "write", { filePath: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
      : []),
    ...(index % 8 === 0
-      ? [toolPart(index, 8, "patch", { patchText: `Update generated patch ${index}` }, 620)]
+      ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
      : []),
    ...(index % 7 === 0
-      ? [toolPart(index, 4, "shell", { command: "bun typecheck", description: "Verify generated output" }, 620)]
+      ? [toolPart(index, 4, "bash", { command: "bun typecheck", description: "Verify generated output" }, 620)]
      : []),
    ...(index % 10 === 0 ? [toolPart(index, 9, "webfetch", { url: "https://example.com/docs/sample" }, 120)] : []),
    ...(index % 11 === 0 ? [toolPart(index, 10, "websearch", { query: "sample movement notes" }, 240)] : []),
@@ -257,15 +256,7 @@ function turn(index: number): SessionMessageInfo[] {
        ]
      : []),
    ...(index % 17 === 0
-      ? [
-          toolPart(
-            index,
-            12,
-            "subagent",
-            { description: "Inspect generated fixture", agent: "explore", prompt: "Inspect the fixture." },
-            160,
-          ),
-        ]
+      ? [toolPart(index, 12, "task", { description: "Inspect generated fixture", subagent_type: "explore" }, 160)]
      : []),
  ]
  return [user, assistantMessage(targetID, index, user.id, parts)]
@@ -281,10 +272,10 @@ const sourceMessages = Array.from({ length: 12 }, (_, index) => [
          toolPart(
            index + 1000,
            1,
-            "subagent",
-            { description: "Inspect child navigation", agent: "explore", prompt: "Inspect child navigation." },
+            "task",
+            { description: "Inspect child navigation", subagent_type: "explore" },
            160,
-            { sessionID: childID },
+            { sessionId: childID },
          ),
        ]
      : []),
@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { inlineThemePreload } from "../../../vite.js"
-import { milestoneForLine, summarizeDesktopStartup, type DesktopStartupSample } from "../devex/desktop-startup"
-
-describe("desktop startup benchmark", () => {
-  test.each(["/oc-theme-preload.js", "./oc-theme-preload.js"])("inlines %s before the renderer runs", (path) => {
-    const html = inlineThemePreload(`<script id="oc-theme-preload-script" src="${path}"></script>`)
-    expect(html).not.toContain(" src=")
-    expect(html).toContain("opencode-color-scheme")
-  })
-
-  test("recognizes startup milestones in colored output", () => {
-    const cases = [
-      ["bunRootScript", "$ bun --cwd packages/desktop dev"],
-      ["bunDesktopScript", "$ bun ./scripts/dev.ts"],
-      ["desktopPrepared", "Copied dev icons from"],
-      ["mainBundleReady", "electron main process built successfully"],
-      ["preloadBundleReady", "electron preload scripts built successfully"],
-      ["rendererDevServerReady", "dev server running for the electron renderer process at:"],
-      ["electronSpawnStarted", "starting electron app..."],
-      ["debugEndpointReady", "DevTools listening on ws://"],
-      ["electronStarted", "app starting"],
-      ["serviceEnsureStarted", "starting v2 background service"],
-      ["serviceSpawnRequested", "v2 CLI background service starting"],
-      ["serviceReady", "v2 CLI background service ready"],
-      ["backgroundLoadingReady", "loading task finished"],
-      ["rendererViteConnected", "[vite] connected."],
-      ["rendererInitializationStarted", "awaiting server ready"],
-      ["rendererInitializationReady", "server ready"],
-      ["windowVisible", "main window visible"],
-    ] as const
-    cases.forEach(([milestone, line]) => {
-      expect(milestoneForLine(`\u001b[32m${line}\u001b[39m`)).toBe(milestone)
-    })
-    expect(milestoneForLine("12:30:00.000 › v2 CLI background service ready {")).toBe("serviceReady")
-    expect(milestoneForLine("unrelated output")).toBeUndefined()
-  })
-
-  test("keeps raw samples and reports median absolute deviation", () => {
-    const samples = [24, 20, 22, 28, 26].map((commandToHomeReadyMs, index) => sample(index + 1, commandToHomeReadyMs))
-    expect(summarizeDesktopStartup(samples).commandToHomeReadyMs).toEqual({
-      min: 20,
-      median: 24,
-      max: 28,
-      medianAbsoluteDeviation: 2,
-    })
-  })
-})
-
-function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample {
-  const milestonesMs = {
-    bunRootScript: 1,
-    bunDesktopScript: 2,
-    desktopPrepared: 3,
-    mainBundleReady: 4,
-    preloadBundleReady: 5,
-    rendererDevServerReady: 6,
-    electronSpawnStarted: 7,
-    debugEndpointReady: 8,
-    electronStarted: 9,
-    serviceEnsureStarted: 10,
-    serviceSpawnRequested: 11,
-    serviceReady: 12,
-    backgroundLoadingReady: 13,
-    rendererViteConnected: 14,
-    rendererInitializationStarted: 15,
-    rendererInitializationReady: 16,
-    windowVisible: 17,
-    homeReady: commandToHomeReadyMs,
-  }
-  return {
-    run,
-    commandToHomeReadyMs,
-    milestonesMs,
-    phasesMs: {
-      desktopPreparation: 3,
-      viteMainBundle: 1,
-      vitePreloadBundle: 1,
-      rendererServerStartup: 1,
-      electronStartup: 2,
-      serviceSpawnWait: 1,
-      serviceProcessStartup: 1,
-      rendererStartup: commandToHomeReadyMs - 14,
-      visibleWindowToHome: commandToHomeReadyMs - 17,
-    },
-    service: { version: "2.0.0-local-test", url: "http://127.0.0.1:3000", pid: run },
-  }
-}
@@ -5,11 +5,9 @@ import { mockOpenCodeServer } from "../../utils/mock-server"
 test("applies message latency after a list response gate is released", async () => {
  const events: string[] = []
  const gate = Promise.withResolvers<void>()
-  const started = Promise.withResolvers<void>()
  let handler: ((route: Route) => Promise<void>) | undefined
  const page = {
    addInitScript: () => Promise.resolve(),
-    on: () => page,
    route: (_url: string, callback: (route: Route) => Promise<void>) => {
      handler = callback
      return Promise.resolve()
@@ -23,7 +21,6 @@ test("applies message latency after a list response gate is released", async ()
    messageDelay: 25,
    beforeMessagesResponse: () => {
      events.push("before")
-      started.resolve()
      return gate.promise
    },
    onMessages: (request) => events.push(request.phase),
@@ -34,18 +31,12 @@ test("applies message latency after a list response gate is released", async ()
  })

  const response = handler!({
-    request: () => ({
-      url: () => "http://127.0.0.1:4096/api/session/session/message",
-      method: () => "GET",
-      headers: () => ({}),
-      postDataBuffer: () => null,
-    }),
+    request: () => ({ url: () => "http://127.0.0.1:4096/api/session/session/message" }),
    fulfill: () => {
      events.push("fulfill")
      return Promise.resolve()
    },
  } as unknown as Route)
-  await started.promise
  expect(events).toEqual(["start", "before"])

  const released = performance.now()
@@ -54,42 +45,3 @@ test("applies message latency after a list response gate is released", async ()
  expect(performance.now() - released).toBeGreaterThanOrEqual(20)
  expect(events).toEqual(["start", "before", "page", "end", "fulfill"])
 })
-
-test("routes requests through the HttpApi contract", async () => {
-  const connected = Promise.withResolvers<{ integrationID: string; body: unknown }>()
-  let handler: ((route: Route) => Promise<void>) | undefined
-  const page = {
-    addInitScript: () => Promise.resolve(),
-    on: () => page,
-    route: (_url: string, callback: (route: Route) => Promise<void>) => {
-      handler = callback
-      return Promise.resolve()
-    },
-  } as unknown as Page
-  await mockOpenCodeServer(page, {
-    provider: {},
-    directory: "C:/OpenCode",
-    project: {},
-    sessions: [],
-    pageMessages: () => ({ items: [] }),
-    onConnectKey: connected.resolve,
-  })
-
-  const body = Buffer.from(JSON.stringify({ key: "secret" }))
-  let status: number | undefined
-  await handler!({
-    request: () => ({
-      url: () => "http://127.0.0.1:4096/api/integration/anthropic/connect/key",
-      method: () => "POST",
-      headers: () => ({ "content-type": "application/json" }),
-      postDataBuffer: () => body,
-    }),
-    fulfill: (response: Parameters<Route["fulfill"]>[0]) => {
-      status = response?.status
-      return Promise.resolve()
-    },
-  } as unknown as Route)
-
-  expect(status).toBe(204)
-  expect(await connected.promise).toEqual({ integrationID: "anthropic", body: { key: "secret" } })
-})
@@ -46,7 +46,7 @@ test("matches the rounded panel corners to the dark new-session background", asy
  )

  await page.goto(`/new-session?draftId=${draftID}`)
-  await expectAppVisible(page.locator('[data-component="composer-editor"]'))
+  await expectAppVisible(page.locator('[data-component="prompt-input"]'))
  await expect(page.locator("html")).toHaveAttribute("data-color-scheme", "dark")
  const panel = page.locator('main div[class*="rounded-[10px]"][class*="overflow-hidden"]')
  await expect(panel).toHaveCount(1)
@@ -60,7 +60,7 @@ test("expands a folder whose path has a trailing Windows separator", async ({ pa
      if (path) return []
      return [
        {
-          name: "",
+          name: "frontend",
          path: "frontend\\",
          absolute: `${directory}/frontend`,
          type: "directory" as const,
@@ -116,7 +116,6 @@ test("expands a folder whose path has a trailing Windows separator", async ({ pa

  const frontendRow = panel.locator('[data-slot="file-tree-v2-row"][data-path="frontend"]')
  await expect(frontendRow).toBeVisible()
-  await expect(frontendRow.getByText("frontend", { exact: true })).toBeVisible()
  await expect(frontendRow).toHaveAttribute("aria-expanded", "false")
  await frontendRow.click()
  await expect(frontendRow).toHaveAttribute("aria-expanded", "true")
@@ -3,9 +3,9 @@ import { base64Encode } from "@opencode-ai/util/encode"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"

-const directory = "C:/OpenCode/ComposerEditing"
-const projectID = "proj_composer_editing"
-const sessionID = "ses_composer_editing"
+const directory = "C:/OpenCode/PromptInputV2Editing"
+const projectID = "proj_prompt_input_v2_editing"
+const sessionID = "ses_prompt_input_v2_editing"
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`

 test("preserves the draft when a populated command menu triggers a built-in", async ({ page }) => {
@@ -15,7 +15,7 @@ test("preserves the draft when a populated command menu triggers a built-in", as
      id: projectID,
      worktree: directory,
      vcs: "git",
-      name: "composer-editing",
+      name: "prompt-input-v2-editing",
      time: { created: 1700000000000, updated: 1700000000000 },
      sandboxes: [],
    },
@@ -23,10 +23,10 @@ test("preserves the draft when a populated command menu triggers a built-in", as
    sessions: [
      {
        id: sessionID,
-        slug: "composer-editing",
+        slug: "prompt-input-v2-editing",
        projectID,
        directory,
-        title: "Composer editing",
+        title: "Prompt input V2 editing",
        version: "dev",
        time: { created: 1700000000000, updated: 1700000000000 },
      },
@@ -34,11 +34,8 @@ test("preserves the draft when a populated command menu triggers a built-in", as
    pageMessages: () => ({ items: [] }),
  })
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-  const composer = page.locator('[data-component="composer"]')
-  const input = composer.locator('[data-component="composer-editor"]')
-  await expect
-    .poll(() => input.evaluate((element) => getComputedStyle(element, "::before").content))
-    .toBe(`"${String.fromCodePoint(0x200b)}"`)
+  const composer = page.locator('[data-component="prompt-input-v2"]')
+  const input = composer.locator('[data-component="prompt-input"]')
  await expectAppVisible(composer)

  await input.fill("keep me")
@@ -8,7 +8,7 @@ const projectID = "proj_prompt_thinking_level_regression"
 const sessionID = "ses_prompt_thinking_level_regression"
 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`

-test("shows the thinking level control while relevant", async ({ page }) => {
+test("shows the V2 thinking level control while relevant", async ({ page }) => {
  await mockOpenCodeServer(page, {
    directory,
    project: {
@@ -51,8 +51,8 @@ test("shows the thinking level control while relevant", async ({ page }) => {
    pageMessages: () => ({ items: [] }),
  })
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-  const composer = page.locator('[data-component="composer"]')
-  const input = composer.locator('[data-component="composer-editor"]')
+  const composer = page.locator('[data-component="prompt-input-v2"]')
+  const input = composer.locator('[data-component="prompt-input"]')
  const control = composer.getByRole("button", { name: "Choose model variant" })
  await expectAppVisible(composer)

@@ -19,10 +19,10 @@ test("session settings use the remote server context", async ({ page }) => {
  await configureServers(page)

  await page.goto(`/server/${base64Encode(serverB)}/session/${sessionB.id}`)
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
  await page.keyboard.press("Control+,")

-  const dialog = page.locator(".settings-dialog")
+  const dialog = page.locator(".settings-v2-dialog")
  const autoAccept = dialog.locator('[data-action="settings-auto-accept-permissions"]')
  const input = autoAccept.getByRole("switch")
  await expect(autoAccept).toBeVisible()
@@ -61,9 +61,9 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>

  const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
  await page.goto(`/server/${base64Encode(serverA)}/session/${sessionA.id}`)
-  await expect(page.getByRole("heading", { name: sessionA.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionA.title).first()).toBeVisible()
  await page.keyboard.press("Control+,")
-  const autoAccept = page.locator(".settings-dialog").locator('[data-action="settings-auto-accept-permissions"]')
+  const autoAccept = page.locator(".settings-v2-dialog").locator('[data-action="settings-auto-accept-permissions"]')
  await autoAccept.locator('[data-slot="switch-control"]').click()
  await expect(autoAccept.getByRole("switch")).toBeChecked()
  await expect
@@ -78,7 +78,7 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>

  await page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefB}"])`).click()
  await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()
  await transport.waitForConnection()

  await transport.send({
@@ -89,7 +89,7 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>
    data: {
      id: "permission-background-a",
      sessionID: sessionA.id,
-      action: "shell",
+      action: "bash",
      resources: ["git status"],
      metadata: {},
      save: [],
@@ -116,7 +116,7 @@ test("auto-accept responds for an unfocused server session", async ({ page }) =>
    data: {
      id: "permission-background-a-child",
      sessionID: childSessionA.id,
-      action: "shell",
+      action: "bash",
      resources: ["git diff"],
      metadata: {},
      save: [],
@@ -208,7 +208,7 @@ async function mockServers(page: Page, permissionRequests: string[], permissionR
      return json(route, [
        {
          id: remote ? sessionB.projectID : "project-server-a",
-          canonical: directory,
+          worktree: directory,
          vcs: "git",
          time: { created: 1, updated: 1 },
          sandboxes: [],
@@ -216,7 +216,7 @@ async function mockServers(page: Page, permissionRequests: string[], permissionR
      ])
    }
    if (url.pathname === "/api/project/current")
-      return json(route, { id: remote ? sessionB.projectID : "project-server-a", directory, canonical: directory })
+      return json(route, { id: remote ? sessionB.projectID : "project-server-a", directory })
    if (url.pathname === "/api/session")
      return json(route, { data: sessions.map((session) => currentSession(session)), cursor: {} })
    if (url.pathname === "/api/session/active") return json(route, { data: {} })
@@ -224,8 +224,6 @@ async function mockServers(page: Page, permissionRequests: string[], permissionR
    if (currentSessionInfo) return json(route, { data: currentSession(currentSessionInfo) })
    if (sessions.some((session) => url.pathname === `/api/session/${session.id}/message`))
      return json(route, { data: [], cursor: {} })
-    if (sessions.some((session) => url.pathname === `/api/session/${session.id}/inbox`))
-      return json(route, { data: [] })
    if (url.pathname === "/api/location") return json(route, { directory })
    if (url.pathname === "/api/vcs")
      return json(route, { location: { directory }, data: { branch: "main", defaultBranch: "main" } })
@@ -239,7 +237,7 @@ function session(id: string, directory: string, title: string) {
    id,
    slug: id,
    projectID: `project-${id}`,
-    location: { directory },
+    directory,
    title,
    version: "dev",
    time: { created: 1, updated: 1 },
@@ -76,7 +76,7 @@ test("keeps the review tree and terminal sized when both panels are open", async
      }),
    })
  })
-  await page.route(/\/api\/pty(?:\?.*)?$/, (route) =>
+  await page.route("**/pty*", (route) =>
    route.fulfill({
      status: 200,
      contentType: "application/json",
@@ -1,79 +0,0 @@
-import type { SessionMessageInfo } from "@opencode-ai/client/promise"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/SessionMessageRevert"
-const projectID = "proj_session_message_revert"
-const sessionID = "ses_session_message_revert"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const messages = [
-  { id: "msg_first", type: "user", text: "First prompt", time: { created: 1 } },
-  {
-    id: "msg_first_reply",
-    type: "assistant",
-    agent: "build",
-    model: { id: "test", providerID: "opencode" },
-    content: [{ type: "text", text: "First reply" }],
-    time: { created: 2, completed: 3 },
-  },
-  { id: "msg_second", type: "user", text: "Second prompt", time: { created: 4 } },
-] satisfies SessionMessageInfo[]
-
-test("reverts directly to the selected user message", async ({ page }) => {
-  const staged: { sessionID: string; messageID: string }[] = []
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      canonical: directory,
-      vcs: "git",
-      name: "session-message-revert",
-      time: { created: 1, updated: 1 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { test: { id: "test", name: "Test", variants: {}, limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "test" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        slug: "session-message-revert",
-        projectID,
-        directory,
-        title: "Session message revert",
-        agent: "build",
-        model: { id: "test", providerID: "opencode" },
-        version: "dev",
-        time: { created: 1, updated: 4 },
-      },
-    ],
-    pageMessages: () => ({ items: messages }),
-    onRevertStage: (input) => staged.push(input),
-  })
-  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-  await expectSessionTitle(page, "Session message revert")
-
-  const message = page.locator('[data-message-id="msg_second"]')
-  await message.hover()
-  const response = page.waitForResponse(
-    (response) =>
-      response.request().method() === "POST" &&
-      new URL(response.url()).pathname === `/api/session/${sessionID}/revert/stage`,
-  )
-  await message.getByRole("button", { name: "Revert message" }).click()
-  expect((await response).ok()).toBe(true)
-
-  await expect(page.getByRole("textbox", { name: "Prompt" })).toHaveText("Second prompt")
-  expect(staged).toEqual([{ sessionID, messageID: "msg_second" }])
-})
@@ -85,7 +85,7 @@ test("shows a pending permission dock", async ({ page }) => {
      {
        id: "permission-request",
        sessionID,
-        permission: "shell",
+        permission: "bash",
        patterns: ["git status", "git diff"],
        metadata: {},
        always: [],
@@ -120,7 +120,7 @@ test("restores the draft caret before typing after a request dock closes", async
  await transport.waitForConnection()
  await expectSessionTitle(page, title)

-  const editor = page.locator('[data-component="composer-editor"][contenteditable="true"]')
+  const editor = page.locator('[data-component="prompt-input"][contenteditable="true"]')
  const draft = "keep the caret at the end"
  await editor.fill(draft)
  await page.evaluate(() => new Promise<void>((resolve) => requestAnimationFrame(() => resolve())))
@@ -2,7 +2,6 @@ import { expect, test, type Locator, type Page } from "@playwright/test"
 import type { JsonValue, OpenCodeEvent, SessionMessageAssistant, SessionMessageInfo } from "@opencode-ai/client/promise"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible, expectSessionTitle } from "../utils/waits"
-import { createTwoFilesPatch } from "diff"

 const directory = "C:/OpenCode/TimelineStateRegression"
 const projectID = "proj_timeline_state_regression"
@@ -41,28 +40,18 @@ const editPart = {
  tool: "edit",
  state: {
    status: "completed",
-    input: {
-      path: "src/regression.ts",
-      oldString: "export const value = 'before'",
-      newString: "export const value = 'after'",
-    },
+    input: { filePath: "src/regression.ts" },
    output: "Edited src/regression.ts",
    title: "src/regression.ts",
    metadata: {
-      files: [
-        {
-          file: "src/regression.ts",
-          patch: createTwoFilesPatch(
-            "a/src/regression.ts",
-            "b/src/regression.ts",
-            "export const value = 'before'\n",
-            "export const value = 'after'\n",
-          ),
-          additions: 1,
-          deletions: 1,
-          status: "modified",
-        },
-      ],
+      filediff: {
+        file: "src/regression.ts",
+        additions: 1,
+        deletions: 1,
+        before: "export const value = 'before'\n",
+        after: "export const value = 'after'\n",
+      },
+      diff: "diff --git a/src/regression.ts b/src/regression.ts\n-export const value = 'before'\n+export const value = 'after'\n",
    },
    time: { start: 1700000001000, end: 1700000002000 },
  },
@@ -160,15 +149,13 @@ test.describe("regression: session timeline local row state", () => {
        ...editPart.state,
        metadata: {
          ...editPart.state.metadata,
-          files: [
-            {
-              file: "src/regression.ts",
-              patch: createTwoFilesPatch("a/src/regression.ts", "b/src/regression.ts", lines, after),
-              additions: 5,
-              deletions: 5,
-              status: "modified",
-            },
-          ],
+          filediff: {
+            file: "src/regression.ts",
+            additions: 1,
+            deletions: 1,
+            before: lines,
+            after,
+          },
        },
      },
    }
@@ -78,7 +78,7 @@ test.describe("regression: session timeline context group resize", () => {
            id("msg_assistant", 10),
            ["read", "glob", "grep", "list"][index]!,
            [
-              { path: "src/recent-a.ts" },
+              { filePath: "src/recent-a.ts" },
              { path: directory, pattern: "**/*.ts" },
              { path: directory, pattern: "Explored" },
              { path: "src" },
@@ -213,7 +213,7 @@ function turn(index: number, target: boolean, status: "running" | "completed" =
            contextIDs[0]!,
            assistantID,
            "read",
-            { path: "src/recent-a.ts", offset: 0, limit: 120 },
+            { filePath: "src/recent-a.ts", offset: 0, limit: 120 },
            status,
          ),
        ),
@@ -270,7 +270,7 @@ function contextTool(
      status,
      input,
      output: `Completed ${tool}.\n${"detail line\n".repeat(8)}`,
-      title: input.path || input.pattern || "completed",
+      title: input.filePath || input.path || input.pattern || "completed",
      metadata: {},
      time: { start: 1700000000000, end: 1700000000100 },
    },
@@ -10,7 +10,7 @@ import {
 test("preserves a collapsed context group through count and status updates", async ({ page }) => {
  const ids = ["prt_closed_01_read", "prt_closed_02_glob"]
  const inputs = {
-    read: { path: "src/a.ts", offset: 0, limit: 120 },
+    read: { filePath: "src/a.ts", offset: 0, limit: 120 },
    glob: { path: ".", pattern: "**/*.ts" },
  }
  const timeline = await setupTimeline(page, {
@@ -7,7 +7,7 @@ test("renders completed write content", async ({ page }) => {
    messages: [
      userMessage(),
      assistantMessage([
-        toolPart(id, "write", "completed", { path: "src/write.ts", content: "export const written = true\n" }),
+        toolPart(id, "write", "completed", { filePath: "src/write.ts", content: "export const written = true\n" }),
      ]),
    ],
    settings: { editToolPartsExpanded: true },
@@ -24,19 +24,20 @@ test("renders a completed single-file patch", async ({ page }) => {
      assistantMessage([
        toolPart(
          id,
-          "patch",
+          "apply_patch",
          "completed",
-          { patchText: "Update src/a.ts" },
+          { files: ["src/a.ts"] },
          {
            metadata: {
              files: [
                {
-                  file: "src/a.ts",
-                  status: "modified",
-                  patch:
-                    "diff --git a/src/a.ts b/src/a.ts\n--- a/src/a.ts\n+++ b/src/a.ts\n@@ -1 +1 @@\n-export const value = 1\n+export const value = 2\n",
+                  filePath: "src/a.ts",
+                  relativePath: "src/a.ts",
+                  type: "update",
                  additions: 1,
                  deletions: 1,
+                  before: "export const value = 1\n",
+                  after: "export const value = 2\n",
                },
              ],
            },
@@ -1,19 +1,18 @@
 import { expect, test } from "@playwright/test"
 import { assistantMessage, setupTimeline, toolPart, userMessage } from "../performance/timeline-stability/fixture"
-import { createTwoFilesPatch } from "diff"

 test("preserves nested patch file state through outer collapse and reopen", async ({ page }) => {
  const patchID = "prt_nested_patch"
-  const files = [patchFile("src/a.ts", "modified"), patchFile("src/b.ts", "added"), patchFile("src/old.ts", "deleted")]
+  const files = [patchFile("src/a.ts", "update"), patchFile("src/b.ts", "add"), patchFile("src/old.ts", "delete")]
  await setupTimeline(page, {
    messages: [
      userMessage(),
      assistantMessage([
        toolPart(
          patchID,
-          "patch",
+          "apply_patch",
          "completed",
-          { patchText: "Update three files" },
+          { files: files.map((file) => file.filePath) },
          { metadata: { files } },
        ),
      ]),
@@ -32,15 +31,15 @@ test("preserves nested patch file state through outer collapse and reopen", asyn
  await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "true")
 })

-function patchFile(file: string, status: "added" | "modified" | "deleted") {
-  const before = status === "added" ? "" : source(false)
-  const after = status === "deleted" ? "" : source(true)
+function patchFile(filePath: string, type: "add" | "update" | "delete") {
  return {
-    file,
-    status,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
-    additions: status === "deleted" ? 0 : 4,
-    deletions: status === "added" ? 0 : 3,
+    filePath,
+    relativePath: filePath,
+    type,
+    additions: type === "delete" ? 0 : 4,
+    deletions: type === "add" ? 0 : 3,
+    before: type === "add" ? undefined : source(false),
+    after: type === "delete" ? undefined : source(true),
  }
 }

@@ -11,7 +11,7 @@ for (const profile of [
      messages: [
        userMessage(),
        assistantMessage([
-          toolPart(ids[0]!, "read", "completed", { path: "src/a.ts" }),
+          toolPart(ids[0]!, "read", "completed", { filePath: "src/a.ts" }),
          toolPart(ids[1]!, "glob", "completed", { path: ".", pattern: "**/*.ts" }),
        ]),
      ],
@@ -12,7 +12,7 @@ import {
 test.describe("session timeline projection", () => {
  test("renders every admitted tool family and hides timeline-only exclusions", async ({ page }) => {
    const parts = [
-      toolPart("prt_01_read", "read", "completed", { path: "src/a.ts" }),
+      toolPart("prt_01_read", "read", "completed", { filePath: "src/a.ts" }),
      toolPart("prt_02_glob", "glob", "completed", { path: ".", pattern: "**/*.ts" }),
      toolPart("prt_03_grep", "grep", "completed", { path: ".", pattern: "value" }),
      toolPart("prt_04_list", "list", "completed", { path: "src" }),
@@ -24,20 +24,16 @@ test.describe("session timeline projection", () => {
        { query: "timeline stability" },
        { output: "https://example.com/result" },
      ),
-      toolPart("prt_task", "subagent", "completed", {
-        description: "Inspect timeline",
-        agent: "explore",
-        prompt: "Inspect the timeline implementation.",
-      }),
+      toolPart("prt_task", "task", "completed", { description: "Inspect timeline", subagent_type: "explore" }),
      toolPart(
        "prt_bash",
-        "shell",
+        "bash",
        "completed",
        { command: "printf stable" },
        { output: "stable", title: "printf stable" },
      ),
      editPart("prt_edit"),
-      toolPart("prt_write", "write", "completed", { path: "src/new.ts", content: "export const stable = true\n" }),
+      toolPart("prt_write", "write", "completed", { filePath: "src/new.ts", content: "export const stable = true\n" }),
      patchPart("prt_patch"),
      toolPart("prt_todo", "todowrite", "completed", { todos: [{ content: "Hidden", status: "pending" }] }),
      toolPart(
@@ -179,10 +175,16 @@ function editPart(id: string) {
    id,
    "edit",
    "completed",
-    { path: "src/a.ts", oldString: "export const value = 1", newString: "export const value = 2" },
+    { filePath: "src/a.ts" },
    {
      metadata: {
-        files: [patchFile("src/a.ts", "modified")],
+        filediff: {
+          file: "src/a.ts",
+          additions: 1,
+          deletions: 1,
+          before: "export const value = 1\n",
+          after: "export const value = 2\n",
+        },
      },
    },
  )
@@ -191,33 +193,31 @@ function editPart(id: string) {
 function patchPart(id: string) {
  return toolPart(
    id,
-    "patch",
+    "apply_patch",
    "completed",
-    { patchText: "Update the projected files" },
+    { files: ["src/a.ts", "src/b.ts"] },
    {
      metadata: {
        files: [
-          patchFile("src/a.ts", "modified"),
-          patchFile("src/b.ts", "added"),
-          patchFile("src/old.ts", "deleted"),
+          patchFile("src/a.ts", "update"),
+          patchFile("src/b.ts", "add"),
+          patchFile("src/old.ts", "delete"),
+          { ...patchFile("src/moved.ts", "move"), move: "src/new-place.ts" },
        ],
      },
    },
  )
 }

-function patchFile(file: string, status: "added" | "modified" | "deleted") {
+function patchFile(filePath: string, type: "add" | "update" | "delete" | "move") {
  return {
-    file,
-    status,
-    patch:
-      status === "added"
-        ? "@@ -0,0 +1 @@\n+export const after = true"
-        : status === "deleted"
-          ? "@@ -1 +0,0 @@\n-export const before = true"
-          : "@@ -1 +1 @@\n-export const before = true\n+export const after = true",
-    additions: status === "deleted" ? 0 : 1,
-    deletions: status === "added" ? 0 : 1,
+    filePath,
+    relativePath: filePath,
+    type,
+    additions: type === "delete" ? 0 : 1,
+    deletions: type === "add" ? 0 : 1,
+    before: type === "add" ? undefined : "export const before = true\n",
+    after: type === "delete" ? undefined : "export const after = true\n",
  }
 }

@@ -15,7 +15,7 @@ import {

 test("groups singleton and separated context operations at correct boundaries", async ({ page }) => {
  const parts = [
-    toolPart("prt_boundary_01_read", "read", "completed", { path: "src/a.ts" }),
+    toolPart("prt_boundary_01_read", "read", "completed", { filePath: "src/a.ts" }),
    textPart("prt_boundary_02_text", "Boundary text"),
    toolPart("prt_boundary_03_glob", "glob", "completed", { path: ".", pattern: "**/*.ts" }),
    toolPart("prt_boundary_04_grep", "grep", "completed", { path: ".", pattern: "stable" }),
@@ -67,18 +67,19 @@ for (const deviceScaleFactor of [1.25, 1.5]) {
 test("keeps the patch card inside a fractionally short virtual row", async ({ page }) => {
  const patchID = "prt_patch_outline"
  const file = {
-    file: "src/outline.ts",
-    status: "modified",
-    patch:
-      "diff --git a/src/outline.ts b/src/outline.ts\n--- a/src/outline.ts\n+++ b/src/outline.ts\n@@ -1 +1 @@\n-const outline = false\n+const outline = true\n",
+    filePath: "src/outline.ts",
+    relativePath: "src/outline.ts",
+    type: "update",
    additions: 1,
    deletions: 1,
+    before: "const outline = false\n",
+    after: "const outline = true\n",
  }
  const timeline = await setupTimeline(page, {
    messages: [
      userMessage(),
      assistantMessage([
-        toolPart(patchID, "patch", "completed", { patchText: "Update src/outline.ts" }, { metadata: { files: [file] } }),
+        toolPart(patchID, "apply_patch", "completed", { files: [file.filePath] }, { metadata: { files: [file] } }),
      ]),
    ],
    settings: { editToolPartsExpanded: true },
@@ -8,7 +8,7 @@ import {
 } from "../performance/timeline-stability/fixture"

 test("renders every tool error outcome without leaking hidden tools", async ({ page }) => {
-  const ordinary = ["shell", "edit", "write", "patch", "webfetch", "websearch", "subagent", "skill", "mcp_probe"]
+  const ordinary = ["bash", "edit", "write", "apply_patch", "webfetch", "websearch", "task", "skill", "mcp_probe"]
  const parts = ordinary.map((tool, index) =>
    toolPart(`prt_error_${index}`, tool, "error", errorInput(tool), { error: `${tool} failed visibly` }),
  )
@@ -37,8 +37,8 @@ test("transitions shell and question through running error outcomes", async ({ p
      userMessage(),
      assistantMessage(
        [
-          toolPart(shellID, "shell", "streaming", { command: "exit 1" }),
-          toolPart(questionID, "question", "streaming", questionInput()),
+          toolPart(shellID, "bash", "pending", { command: "exit 1" }),
+          toolPart(questionID, "question", "pending", questionInput()),
        ],
        { completed: false },
      ),
@@ -46,11 +46,11 @@ test("transitions shell and question through running error outcomes", async ({ p
  })
  await timeline.waitForPart(shellID)
  await expect(page.locator(`[data-timeline-part-id="${questionID}"]`)).toHaveCount(0)
-  await timeline.send(partUpdated(toolPart(shellID, "shell", "running", { command: "exit 1" })), 120)
+  await timeline.send(partUpdated(toolPart(shellID, "bash", "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", "error", { command: "exit 1" }, { error: "Command exited 1" })),
+    partUpdated(toolPart(shellID, "bash", "error", { command: "exit 1" }, { error: "Command exited 1" })),
    180,
  )
  await timeline.send(
@@ -103,7 +103,7 @@ test("labels completed searches with result counts", async ({ page }) => {
  await expect(rows.nth(1)).toContainText("(12 matches)")
 })

-test("labels read tools from their path input", async ({ page }) => {
+test("labels V2 read tools from their path input", async ({ page }) => {
  const id = "prt_read_path"
  await setupTimeline(page, {
    messages: [userMessage(), assistantMessage([toolPart(id, "read", "completed", { path: "src/a.ts" })])],
@@ -114,7 +114,7 @@ test("labels read tools from their path input", async ({ page }) => {
  await expect(group.locator('[data-slot="basic-tool-tool-subtitle"]')).toHaveText("a.ts")
 })

-test("labels skill tools from IDs and result metadata", async ({ page }) => {
+test("labels V2 skill tools from IDs and result metadata", async ({ page }) => {
  const pending = "prt_skill_id"
  const completed = "prt_skill_name"
  await setupTimeline(page, {
@@ -131,10 +131,9 @@ test("labels skill tools from IDs and result metadata", async ({ page }) => {
    "aria-label",
    "sample-skill",
  )
-  await expect(page.locator(`[data-timeline-part-id="${completed}"] [data-component="text-shimmer"]`)).toHaveAttribute(
-    "aria-label",
-    "OpenCode",
-  )
+  await expect(
+    page.locator(`[data-timeline-part-id="${completed}"] [data-component="text-shimmer"]`),
+  ).toHaveAttribute("aria-label", "OpenCode")
  for (const id of [pending, completed]) {
    const skill = page.locator(`[data-timeline-part-id="${id}"]`)
    await expect(skill.locator('[data-slot="skill-tool-label"]')).toHaveText("Skill")
@@ -148,12 +147,12 @@ function questionInput() {
 }

 function errorInput(tool: string) {
-  if (tool === "shell") return { command: "exit 1" }
-  if (["edit", "write"].includes(tool)) return { path: "src/error.ts", content: "" }
-  if (tool === "patch") return { patchText: "Update src/error.ts" }
+  if (tool === "bash") return { command: "exit 1" }
+  if (["edit", "write"].includes(tool)) return { filePath: "src/error.ts", content: "" }
+  if (tool === "apply_patch") return { files: ["src/error.ts"] }
  if (tool === "webfetch") return { url: "https://example.com" }
  if (tool === "websearch") return { query: "failure" }
-  if (tool === "subagent") return { description: "Fail subagent", agent: "explore", prompt: "Inspect the failure." }
+  if (tool === "task") return { description: "Fail task", subagent_type: "explore" }
  if (tool === "skill") return { name: "failure" }
  return { target: "failure" }
 }
@@ -87,7 +87,7 @@ test("reconnects after a stream error", async ({ page }) => {
  expect((await timeline.transport.connections())[0]?.endedBy).toBe("error")
 })

-test("does not request replay when reconnecting the volatile event stream", async ({ page }) => {
+test("does not request replay when reconnecting the volatile V2 event stream", async ({ page }) => {
  const timeline = await setupTimeline(page, { eventRetry: 10 })
  const events = partUpdated(textPart("prt_transport_id", "event with id"))
  const first = (
@@ -167,14 +167,14 @@ function parentMessages(): SessionMessageInfo[] {
      content: [
        {
          type: "tool",
-          id: "call_subagent_0001",
-          name: "subagent",
+          id: "call_task_0001",
+          name: "task",
          time: { created: 1700000001000, ran: 1700000001000, completed: 1700000002000 },
          state: {
            status: "completed",
-            input: { description: taskDescription, agent: "explore", prompt: "Inspect the delegated work." },
+            input: { description: taskDescription, subagent_type: "explore" },
            content: [{ type: "text", text: "Subagent finished" }],
-            metadata: { sessionID: childID },
+            metadata: { sessionId: childID },
          },
        },
      ],
@@ -77,7 +77,7 @@ test("routes typing to the composer unless the open terminal is focused", async
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
  await expectSessionTitle(page, "Terminal composer focus")

-  const composer = page.locator('[data-component="composer-editor"]')
+  const composer = page.locator('[data-component="prompt-input"]')
  const terminal = page.locator('[data-component="terminal"]')
  await page.keyboard.press("Control+Backquote")
  await expect(terminal).toBeVisible()
@@ -116,7 +116,7 @@ test("keeps composer focus when a cached terminal finishes mounting", async ({ p
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`, { waitUntil: "commit" })
  await expectSessionTitle(page, "Terminal composer focus")

-  const composer = page.locator('[data-component="composer-editor"]')
+  const composer = page.locator('[data-component="prompt-input"]')
  const terminal = page.locator('[data-component="terminal"]')
  await expect(terminal).toBeVisible()
  expect(created.count).toBe(0)
@@ -142,7 +142,7 @@ test("keeps newer composer focus while an explicit terminal open finishes", asyn
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
  await expectSessionTitle(page, "Terminal composer focus")

-  const composer = page.locator('[data-component="composer-editor"]')
+  const composer = page.locator('[data-component="prompt-input"]')
  const terminal = page.locator('[data-component="terminal"]')
  await page.keyboard.press("Control+Backquote")
  await expect(terminal).toBeVisible()
@@ -187,7 +187,7 @@ test("focuses a terminal created from the new-terminal button", async ({ page })
  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
  await expectSessionTitle(page, "Terminal composer focus")

-  const composer = page.locator('[data-component="composer-editor"]')
+  const composer = page.locator('[data-component="prompt-input"]')
  const terminal = page.locator('[data-component="terminal"]')
  await page.keyboard.press("Control+Backquote")
  await expect(terminal.locator("textarea")).toHaveCount(1)
@@ -1,7 +1,7 @@
 import { createResource, createSignal, For, onMount, Suspense } from "solid-js"
 import { render } from "solid-js/web"
 import { createVirtualizer, observeElementOffset, observeElementRect } from "@tanstack/solid-virtual"
-import { observeElementOffsetReconnectAware } from "../../../src/session/timeline/observe-element-offset"
+import { observeElementOffsetReconnectAware } from "../../../src/pages/session/timeline/observe-element-offset"

 const rowCount = 2_000
 const rowHeight = 40
@@ -1,5 +1,3 @@
-import { createTwoFilesPatch } from "diff"
-
 const words = [
  "alpha",
  "bravo",
@@ -30,21 +28,22 @@ const directory = "C:/OpenCode/SmokeProject"
 const projectID = "proj_smoke_timeline"
 const model = { providerID: "opencode", modelID: "claude-opus-4-6", variant: "max" }

-type MessagePart =
-  | { id: string; type: "text"; text: string }
-  | { id: string; type: "reasoning"; text: string; time?: { start: number; end?: number } }
-  | {
-      id: string
-      type: "tool"
-      name: string
-      state: {
-        status: "completed"
-        input: Record<string, unknown>
-        content: [{ type: "text"; text: string }]
-        metadata: Record<string, unknown>
-      }
-      time: { created: number; ran: number; completed: number }
-    }
+type MessagePart = {
+  id: string
+  type: "text" | "reasoning" | "tool"
+  text?: string
+  time?: { start: number; end?: number }
+  callID?: string
+  tool?: string
+  state?: {
+    status: "completed"
+    input: Record<string, unknown>
+    output: string
+    title: unknown
+    metadata: Record<string, unknown>
+    time: { start: number; end: number }
+  }
+}

 function lorem(seed: number, length: number) {
  let out = ""
@@ -103,16 +102,17 @@ function messageContent(part: MessagePart): SessionMessageAssistant["content"][n
        ? { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) }
        : undefined,
    }
+  const state = part.state!
  return {
    type: "tool",
-    id: part.id,
-    name: part.name,
-    time: part.time,
+    id: part.callID ?? part.id,
+    name: part.tool!,
+    time: { created: state.time.start, ran: state.time.start, completed: state.time.end },
    state: {
      status: "completed",
-      input: part.state.input as Record<string, JsonValue>,
-      content: part.state.content,
-      metadata: part.state.metadata as Record<string, JsonValue>,
+      input: state.input as Record<string, JsonValue>,
+      content: [{ type: "text", text: state.output }],
+      metadata: state.metadata as Record<string, JsonValue>,
    },
  }
 }
@@ -138,61 +138,60 @@ function toolPart(
  outputLength = 160,
 ): MessagePart {
  const metadata =
-    tool === "patch"
-      ? {
-          files: [
-            patchFile(index, "modified"),
-            patchFile(index + 1, index % 2 === 0 ? "added" : "deleted"),
-          ],
-        }
+    tool === "apply_patch"
+      ? { files: [patchFile(index, "update"), patchFile(index + 1, index % 2 === 0 ? "add" : "delete")] }
      : tool === "edit" || tool === "write"
-        ? { files: [fileDiff(String(input.path ?? `src/generated/file-${index}.ts`), index)] }
+        ? {
+            filediff: fileDiff(String(input.filePath ?? `src/generated/file-${index}.ts`), index),
+            diff: patch(index, outputLength),
+            preview: patch(index + 1, 420),
+          }
        : tool === "question"
          ? { answers: [["Proceed"], ["Keep sample output"]] }
          : {}
  return {
-    id: id(`call_${tool}_${partIndex}`, index),
+    id: id(`prt_tool_${tool}_${partIndex}`, index),
    type: "tool",
-    name: tool,
+    callID: id("call", index * 100 + partIndex),
+    tool,
    state: {
      status: "completed",
      input,
-      content: [{ type: "text", text: lorem(index * 23 + partIndex, outputLength) }],
+      output: lorem(index * 23 + partIndex, outputLength),
+      title: tool === "bash" ? input.command : input.filePath || input.path || input.pattern || "completed",
      metadata,
-    },
-    time: {
-      created: 1700000000000 + index * 10_000,
-      ran: 1700000000000 + index * 10_000,
-      completed: 1700000000000 + index * 10_000 + 400,
+      time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
    },
  }
 }

-function patchFile(seed: number, status: "added" | "modified" | "deleted") {
-  const file = `src/generated/patch-${seed}.ts`
-  const before = status === "added" ? "" : code(seed, 18)
-  const after = status === "deleted" ? "" : code(seed + 1, 24)
+function patchFile(seed: number, type: "add" | "update" | "delete") {
  return {
-    file,
-    status,
-    additions: status === "deleted" ? 0 : (seed % 7) + 1,
-    deletions: status === "added" ? 0 : seed % 4,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    filePath: `src/generated/patch-${seed}.ts`,
+    relativePath: `src/generated/patch-${seed}.ts`,
+    type,
+    additions: (seed % 7) + 1,
+    deletions: type === "add" ? 0 : seed % 4,
+    patch: patch(seed, 520),
+    before: type === "add" ? undefined : code(seed, 18),
+    after: type === "delete" ? undefined : code(seed + 1, 24),
  }
 }

 function fileDiff(file: string, seed: number) {
-  const before = code(seed, 32)
-  const after = code(seed + 1, 38)
  return {
    file,
-    status: "modified" as const,
    additions: (seed % 9) + 1,
    deletions: seed % 4,
-    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    before: code(seed, 32),
+    after: code(seed + 1, 38),
  }
 }

+function patch(seed: number, length: number) {
+  return `diff --git a/src/generated/file-${seed}.ts b/src/generated/file-${seed}.ts\n+${lorem(seed, length).replace(/\n/g, "\n+")}`
+}
+
 function code(seed: number, lines: number) {
  return Array.from({ length: lines }, (_, index) => `export const value${index} = "${lorem(seed + index, 32)}"`).join(
    "\n",
@@ -206,23 +205,21 @@ function turn(index: number): SessionMessageInfo[] {
    ...(index % 5 === 0 ? [reasoningPart(index, 0, 420)] : []),
    ...(index % 3 === 0
      ? [
-          toolPart(index, 0, "read", { path: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
+          toolPart(index, 0, "read", { filePath: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
          toolPart(index, 5, "glob", { path: directory, pattern: `**/*sample-${index}*.ts` }, 140),
          toolPart(index, 1, "grep", { path: directory, pattern: `sample-${index}`, include: "*.ts" }, 180),
          toolPart(index, 6, "list", { path: `src/generated/${index}` }, 120),
        ]
      : []),
    textPart(index, 2, 160 + (index % 6) * 90),
-    ...(index % 4 === 0
-      ? [toolPart(index, 3, "edit", { path: `src/generated/file-${index}.ts`, oldString: "before", newString: "after" }, 700)]
-      : []),
+    ...(index % 4 === 0 ? [toolPart(index, 3, "edit", { filePath: `src/generated/file-${index}.ts` }, 700)] : []),
    ...(index % 6 === 0
-      ? [toolPart(index, 7, "write", { path: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
+      ? [toolPart(index, 7, "write", { filePath: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
      : []),
    ...(index % 8 === 0
-      ? [toolPart(index, 8, "patch", { patchText: `Update generated patch ${index}` }, 620)]
+      ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
      : []),
-    ...(index % 7 === 0 ? [toolPart(index, 4, "shell", { command: "bun typecheck" }, 620)] : []),
+    ...(index % 7 === 0 ? [toolPart(index, 4, "bash", { command: "bun typecheck" }, 620)] : []),
    ...(index % 10 === 0 ? [toolPart(index, 9, "webfetch", { url: "https://example.com/docs/sample" }, 120)] : []),
    ...(index % 11 === 0 ? [toolPart(index, 10, "websearch", { query: "sample movement notes" }, 240)] : []),
    ...(index % 13 === 0
@@ -237,15 +234,7 @@ function turn(index: number): SessionMessageInfo[] {
        ]
      : []),
    ...(index % 17 === 0
-      ? [
-          toolPart(
-            index,
-            12,
-            "subagent",
-            { description: "Inspect generated fixture", agent: "explore", prompt: "Inspect the fixture." },
-            160,
-          ),
-        ]
+      ? [toolPart(index, 12, "task", { description: "Inspect generated fixture", subagent_type: "explore" }, 160)]
      : []),
  ]
  return [user, assistantMessage(targetID, index, user.id, parts)]
@@ -322,7 +311,7 @@ export const fixture = {
    targetPartIDs: targetMessages.flatMap(currentPartIDs),
    expandedShellPartID: targetMessages
      .flatMap((message) => (message.type === "assistant" ? message.content : []))
-      .flatMap((part) => (part.type === "tool" && part.name === "shell" ? [part.id] : []))[0],
+      .flatMap((part) => (part.type === "tool" && part.name === "bash" ? [part.id] : []))[0],
  },
 }

--- a/Show More
+++ b/Show More