chore: update nix node_modules hashes

Signed-off-by: Major Hayden <major@mhtx.net>

.changeset/idempotent-prompt-reuse.md

@@ -0,0 +1,5 @@
+---
+"@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.

.changeset/share-session-model-request.md

@@ -0,0 +1,5 @@
+---
+"@opencode-ai/core": patch
+---
+
+Apply shared Session model-request preparation to transient generation.

.changeset/steer-resume-simplified.md

@@ -0,0 +1,5 @@
+---
+"@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.

AGENTS.md

@@ -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. 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.
+- 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.
 - 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.

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-IxkSw0gK/qkMHZGVHqjwgM9BKhzbQX6hyF9SWUNtpzg=",
-    "aarch64-linux": "sha256-YVjpbil0QswVwi6NtVYFq3xCqpsfveG1chlNVCVI0MU=",
-    "aarch64-darwin": "sha256-CdL2mI84pawH2H5i9qu8A6IWbkmKOYHlJS+DI/Mafdw=",
-    "x86_64-darwin": "sha256-NtswwfU5WYv99bEmI4XeLwjhBGcS9ZMYLRo4MQRNtLo="
+    "x86_64-linux": "sha256-JEqi00PCle+o5OfBlJJaZtXd+4sYB3o+rvYiESlN4dY=",
+    "aarch64-linux": "sha256-zk3Uk1SQyeRrQ7BuFwlOnQAptUHIkq+oPdfd+sTEq5U=",
+    "aarch64-darwin": "sha256-3BOd3EcqimoG3rTI6lTHe91YVlCoEi8/68eT1lbOi0c=",
+    "x86_64-darwin": "sha256-X7wGmjiMloF5Zhuc20kAxLC+tl613YNXRgA+dQjP2WM="
   }
 }

package.json

@@ -15,6 +15,7 @@
     "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",
@@ -37,10 +38,10 @@
       "packages/slack"
     ],
     "catalog": {
-      "@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",
+      "@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",
       "@npmcli/arborist": "9.4.0",
       "@types/bun": "1.3.13",
       "@types/cross-spawn": "6.0.6",
@@ -71,7 +72,7 @@
       "dompurify": "3.3.1",
       "drizzle-kit": "1.0.0-rc.2",
       "drizzle-orm": "1.0.0-rc.2",
-      "effect": "4.0.0-beta.107",
+      "effect": "4.0.0-rc.110",
       "ai": "6.0.168",
       "cross-spawn": "7.0.6",
       "hono": "4.10.7",

packages/ai/AGENTS.md

@@ -71,7 +71,7 @@ export const route = Route.make({
 })
 ```
 
-Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry model identity and the configured route; low-level callers may also attach model-specific defaults and compatibility metadata. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
+Route defaults are request-shaping defaults such as `headers`, `limits`, `generation`, `providerOptions`, and `http`. Endpoint host/query belongs on the route endpoint. Selected `LanguageModel` values carry only model id, provider id, and the configured route value. Model capability/catalog metadata lives outside this package; protocol support is enforced by request lowering and typed `AIError`s.
 
 The four-axis decomposition is the reason DeepSeek, TogetherAI, Cerebras, Baseten, Fireworks, and DeepInfra all reuse `OpenAIChat.protocol` verbatim — each provider deployment is a 5-15 line `Route.make(...)` call instead of a 300-400 line route clone. Bug fixes in one protocol propagate to every consumer of that protocol in a single commit.
 
@@ -88,7 +88,7 @@ For providers where the URL is derived from typed inputs (Azure resource name, B
 Provider-facing APIs are configured facades over route values. Endpoint/auth/resource/API-version setup happens before model selection, and model selectors accept only a model or deployment id:
 
 ```ts
-const openai = OpenAI.configure({ apiKey, baseURL, store: false })
+const openai = OpenAI.configure({ apiKey, baseURL })
 const model = openai.responses("gpt-4o-mini")
 
 const azure = Azure.configure({ resourceName, apiKey, apiVersion: "v1" })
@@ -108,22 +108,17 @@ Keep provider facades small and explicit:
 - Resolve `apiKey` → `Auth` with `AuthOptions.bearer(options, "<PROVIDER>_API_KEY")` (it honors an explicit `auth` override and falls back to `Auth.config(envVar)` so missing keys surface a typed `Authentication` error rather than a runtime crash).
 - Use separate top-level facades for products with different required setup, such as `CloudflareAIGateway` and `CloudflareWorkersAI`.
 
-Provider facades and model-derived `LLMRequest.providerOptions` are provider-specific, so expose typed native options flat at those boundaries. Provider package settings keep deployment configuration separate from their typed `providerOptions` field, except facades such as OpenAI whose settings are already unambiguous when flat. The selected `LanguageModel<Options>` carries request-option typing; the route decodes the flat runtime record. Keep provider metadata namespaced because replay may contain metadata from multiple layers.
-
 `Provider.make(...)` remains available for simple static provider definitions, but new built-in providers should prefer plain configured facades unless a helper removes real duplication without adding runtime behavior.
 
 ### Provider Package Entrypoints
 
-Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model({ id, settings, credential, defaults })`. Core selects and refreshes the optional `key | oauth` credential; the provider package interprets it as route authentication. Serializable provider settings remain separate from common `headers`, `body`, and `limits` defaults.
+Catalog-selected native providers use package-like export paths from `@opencode-ai/ai`. They are internal entrypoints in one npm package, not separately published provider packages. Every entrypoint implements `ProviderPackage.Definition` and exposes `model(modelID, settings)`, where settings are serializable provider configuration plus common `headers`, `body`, and `limits` overlays.
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
 
-const selected = model({
-  id: "gpt-5",
-  settings: {},
-  credential: { type: "key", value: apiKey },
-  defaults: {},
+const selected = model("gpt-5", {
+  apiKey,
 })
 ```
 

packages/ai/README.md

@@ -305,26 +305,18 @@ const gateway = CloudflareAIGateway.configure({
 }).model("workers-ai/@cf/meta/llama-3.1-8b-instruct")
 ```
 
-Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint. GitHub Copilot remains a Core-owned AI SDK integration rather than an AI-package provider.
+Included providers: OpenAI, Anthropic, Google (Gemini), Google Vertex Gemini and Anthropic, Amazon Bedrock, Azure OpenAI, Cloudflare AI Gateway, Cloudflare Workers AI, GitHub Copilot, OpenRouter, xAI, Z.ai, plus generic OpenAI-compatible Chat and Responses entrypoints and an Anthropic Messages-compatible entrypoint.
 
 ### 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({ id, settings, credential, defaults })` contract. Core selects and refreshes the optional `key | oauth` credential, while the provider package interprets it as route authentication. Serializable provider settings remain separate from common `headers`, `body`, and `limits` defaults.
+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.
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/openai/responses"
 
-const apiKey = process.env.OPENAI_API_KEY
-if (!apiKey) throw new Error("OPENAI_API_KEY is required")
-
-const selected = model({
-  id: "gpt-5",
-  settings: {},
-  credential: { type: "key", value: apiKey },
-  defaults: {
-    headers: { "x-application": "opencode" },
-    limits: { context: 200_000, output: 64_000 },
-  },
+const selected = model("gpt-5", {
+  apiKey: process.env.OPENAI_API_KEY,
+  headers: { "x-application": "opencode" },
 })
 ```
 
@@ -348,57 +340,30 @@ Tuned Vertex Gemini deployments use model ids shaped like `endpoints/1234567890`
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/gemini"
 
-model({
-  id: "gemini-3.5-flash",
-  settings: { project: "my-project", location: "global" },
-  defaults: {},
-})
+model("gemini-3.5-flash", { project: "my-project", location: "global" })
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/chat"
 
-model({
-  id: "deepseek-ai/deepseek-v3.2-maas",
-  settings: { project: "my-project", location: "global" },
-  defaults: {},
-})
+model("deepseek-ai/deepseek-v3.2-maas", { project: "my-project", location: "global" })
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/responses"
 
-model({
-  id: "xai/grok-4.20-reasoning",
-  settings: { project: "my-project", location: "global" },
-  defaults: {},
-})
+model("xai/grok-4.20-reasoning", { project: "my-project", location: "global" })
 ```
 
 ```ts
 import { model } from "@opencode-ai/ai/providers/google-vertex/messages"
 
-model({
-  id: "claude-sonnet-4-6",
-  settings: { project: "my-project", location: "global" },
-  defaults: {},
-})
+model("claude-sonnet-4-6", { project: "my-project", location: "global" })
 ```
 
-Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path. The entrypoints listed above implement that contract and are covered by `test/provider-package.test.ts`.
+Provider facades such as `OpenAI.configure(...).responses(...)` remain the direct application API. Package-like entrypoints are the self-similar loading contract used when a catalog selects behavior by export path.
 
-## How OpenCode uses this package
-
-OpenCode does not call provider facades directly from the CLI or server. Core owns the integration:
-
-1. `packages/core/src/model-resolver.ts` resolves catalog metadata and an active integration credential into a `LanguageModel`. Native package entrypoints expose `model({ id, settings, credential, defaults })`; catalog packages without a native mapping fall back through Core's AI SDK adapter.
-2. `packages/core/src/session/model-request.ts` lowers Session state, instructions, tools, and plugin hooks into one canonical `LLMRequest`.
-3. `packages/core/src/session/runner/llm.ts` calls the yielded `LLMClient.Service` once per physical attempt and persists provider-neutral `LLMEvent`s.
-4. Core owns retries, continuation, compaction, permissions, durable tool execution, and Session history. None of that orchestration belongs in this package.
-
-Title generation, compaction, standalone generation, and transient Session generation also build `LLMRequest`s and use the same `LLMClient.Service`. Core's `AISDK` adapter wraps remaining Vercel AI SDK models in executable routes so native and fallback providers present the same request and event model to callers.
-
-This separation is intentional: `@opencode-ai/ai` owns one model call, provider protocols, and transport; Core owns the durable agent runtime.
+Other provider exports listed above remain direct facades until they explicitly implement the package-like contract. Exporting a provider facade does not implicitly make it a catalog-loadable provider package.
 
 ## Provider options & HTTP overlays
 
@@ -411,16 +376,6 @@ Request options in order of stability:
 
 Route/provider defaults are overridden by request-level values for each axis.
 
-Provider-specific facades accept their own options directly because the provider is already known:
-
-```ts
-const model = OpenAI.configure({
-  apiKey,
-  store: false,
-  reasoningEffort: "high",
-}).responses("gpt-5")
-```
-
 The selected model supplies the provider-specific option type, so per-request overrides stay flat while the canonical runtime request remains provider-neutral:
 
 ```ts

packages/ai/example/tutorial.ts

@@ -17,12 +17,13 @@ import { OpenAI } from "@opencode-ai/ai/providers"
 const apiKey = Config.redacted("OPENAI_API_KEY")
 
 // 1. Pick a model. The provider helper records provider identity, protocol
-// choice, deployment options, authentication, and defaults. Catalog capabilities
-// remain application-owned and are not part of LanguageModel.
+// choice, capabilities, deployment options, authentication, and defaults.
 const model = OpenAI.configure({
   apiKey,
   generation: { maxTokens: 160 },
-  store: false,
+  providerOptions: {
+    store: false,
+  },
 }).model("gpt-4o-mini")
 
 // 2. Build a provider-neutral request. This is useful when reusing one request
@@ -73,8 +74,8 @@ const streamText = LLM.stream(request).pipe(
   Stream.runDrain,
 )
 
-// 5. Tools are typed with Effect Schema. Model calls remain explicit:
-// advertise definitions on the request, stream one call, dispatch local calls,
+// 5. Tools are typed with Effect Schema. Provider turns remain explicit:
+// advertise definitions on the request, stream one turn, dispatch local calls,
 // then persist/build follow-up history in the enclosing product flow.
 const tools = {
   get_weather: Tool.make({
@@ -101,7 +102,7 @@ const streamWithTools = Effect.gen(function* () {
     console.log("tool result", event.name, dispatched.result)
 
     // A durable agent would persist these messages before starting another
-    // model call. This tutorial keeps the boundary visible instead.
+    // raw model turn. This tutorial keeps the boundary visible instead.
     const followUp = LLMRequest.update(request, {
       messages: [
         ...request.messages,

packages/ai/src/index.ts

@@ -37,9 +37,6 @@ export type {
   LanguageModelOptions as ProviderLanguageModelOptions,
 } from "./provider.js"
 export type {
-  Credential as ProviderPackageCredential,
-  Defaults as ProviderPackageDefaults,
   Definition as ProviderPackageDefinition,
-  ModelInput as ProviderPackageModelInput,
   Settings as ProviderPackageSettings,
 } from "./provider-package.js"

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

@@ -31,6 +31,7 @@ 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
 
 export type ThinkingInput =
   | {
@@ -624,7 +625,6 @@ 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.
@@ -663,7 +663,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
     tools,
     tool_choice: toolChoice,
     stream: true as const,
-    max_tokens: generation?.maxTokens ?? outputLimit,
+    max_tokens: generation?.maxTokens ?? DEFAULT_MAX_TOKENS,
     temperature: generation?.temperature,
     top_p: generation?.topP,
     top_k: generation?.topK,

packages/ai/src/protocols/gemini.ts

@@ -289,7 +289,9 @@ 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)
-      if (previous?.role === "user")
+      // 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))
         contents[contents.length - 1] = { role: "user", parts: [...previous.parts, { text: part.text }] }
       else contents.push({ role: "user", parts: [{ text: part.text }] })
       continue

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

@@ -93,6 +93,8 @@ 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),
@@ -101,6 +103,7 @@ 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,
@@ -115,6 +118,8 @@ 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
@@ -128,8 +133,6 @@ 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,
@@ -159,6 +162,14 @@ 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),
@@ -179,6 +190,8 @@ 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({
@@ -288,6 +301,20 @@ 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
@@ -353,34 +380,42 @@ export const lowerToolChoice = (protocolName: string, toolChoice: NonNullable<LL
     tool: (toolName) => ({ type: "function" as const, name: toolName }),
   })
 
-const lowerToolCall = (part: ToolCallPart): OpenResponsesInputItem => ({
-  type: "function_call",
-  call_id: part.id,
-  name: part.name,
-  arguments: ProviderShared.encodeJson(part.input),
-})
+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 lowerReasoning = (part: ReasoningPart, providerMetadataKey: string): OpenResponsesReasoningInput | undefined => {
   const metadata = part.providerMetadata?.[providerMetadataKey]
-  if (!ProviderShared.isRecord(metadata) || typeof metadata.itemId !== "string" || metadata.itemId.length === 0)
-    return undefined
+  const id = itemID(part.providerMetadata, providerMetadataKey)
+  if (!ProviderShared.isRecord(metadata) || !id) return undefined
   const encryptedContent =
     typeof metadata.reasoningEncryptedContent === "string" || metadata.reasoningEncryptedContent === null
       ? metadata.reasoningEncryptedContent
       : undefined
   return {
     type: "reasoning",
-    id: metadata.itemId,
+    id,
     summary: part.text.length > 0 ? [{ type: "summary_text", text: part.text }] : [],
     encrypted_content: encryptedContent,
   }
 }
 
 const hostedToolItemID = (part: ToolResultPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.itemId === "string" && metadata.itemId.length > 0
-    ? metadata.itemId
-    : undefined
+  return itemID(part.providerMetadata, providerMetadataKey)
 }
 
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (
@@ -465,24 +500,26 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
 
     if (message.role === "assistant") {
       const content: TextPart[] = []
-      const reasoningItems: Record<string, OpenResponsesReasoningReplay> = {}
+      const reasoningItems: Record<string, OpenResponsesReasoningInput> = {}
       const reasoningReferences = new Set<string>()
       const hostedToolReferences = new Set<string>()
       const flushText = () => {
         if (content.length === 0) return
-        const groups = content.reduce<Array<{ phase: MessagePhase | null | undefined; parts: TextPart[] }>>(
-          (groups, part) => {
-            const metadata = part.providerMetadata?.[providerMetadataKey]
-            const phase = ProviderShared.isRecord(metadata) ? messagePhase(metadata.phase, extension) : undefined
-            const group = groups.at(-1)
-            if (group && group.phase === phase) group.parts.push(part)
-            else groups.push({ phase, parts: [part] })
-            return groups
-          },
-          [],
-        )
+        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
+        }, [])
         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 }),
@@ -511,19 +548,14 @@ const lowerMessages = Effect.fn("OpenResponses.lowerMessages")(function* (reques
               existing.encrypted_content = reasoning.encrypted_content
             continue
           }
-          const replay = {
-            type: reasoning.type,
-            summary: reasoning.summary,
-            encrypted_content: reasoning.encrypted_content,
-          }
-          reasoningItems[reasoning.id] = replay
-          input.push(replay)
+          reasoningItems[reasoning.id] = reasoning
+          input.push(reasoning)
           continue
         }
         if (part.type === "tool-call") {
           flushText()
           if (part.providerExecuted === true) continue
-          input.push(lowerToolCall(part))
+          input.push(lowerToolCall(part, providerMetadataKey))
           continue
         }
         if (part.type === "tool-result" && part.providerExecuted === true) {
@@ -578,6 +610,12 @@ 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
@@ -627,6 +665,8 @@ 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),
   }
 })
@@ -695,7 +735,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 = phase === undefined ? undefined : providerMetadata(state, { phase })
+  const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
   const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
@@ -924,7 +964,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           state.lifecycle,
           events,
           item.id,
-          phase === undefined ? undefined : providerMetadata(state, { phase }),
+          providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
         ),
         messageItems,
         messagePhases,
@@ -937,7 +977,11 @@ 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 })
+      : ToolStream.start(state.tools, item.id, {
+          id: item.call_id,
+          name: item.name,
+          providerMetadata: providerMetadata(state, { itemId: item.id }),
+        })
     const result =
       item.arguments === undefined
         ? yield* ToolStream.finish(state.id, tools, item.id)
@@ -988,11 +1032,19 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   return [state, NO_EVENTS] satisfies StepResult
 })
 
-const onResponseFinish = (state: ParserState, event: Event): StepResult => {
-  const events: LLMEvent[] = []
+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 lifecycle = Lifecycle.finish(state.lifecycle, events, {
     reason: {
-      normalized: mapFinishReason(event, state.hasFunctionCall),
+      normalized: mapFinishReason(event, hasFunctionCall),
       raw: event.response?.incomplete_details?.reason,
     },
     usage: mapUsage(event.response?.usage, state.providerMetadataKey),
@@ -1004,8 +1056,8 @@ const onResponseFinish = (state: ParserState, event: Event): StepResult => {
           })
         : undefined,
   })
-  return [{ ...state, lifecycle }, events]
-}
+  return [{ ...state, lifecycle, hasFunctionCall, tools: pending.tools }, events] satisfies StepResult
+})
 
 // Build a single human-readable message from whatever the provider supplied.
 // When both code and message are present, prefix the code so consumers see
@@ -1047,6 +1099,14 @@ 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))
@@ -1074,8 +1134,7 @@ 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 Effect.succeed(onResponseFinish(state, event))
+  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
   if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
   if (event.type === "error")
     return decodeKnownErrorEvent(event).pipe(

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

@@ -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", "tool_calls"])
+const RESERVED_REASONING_FIELDS = new Set(["role", "content", "refusal", "tool_calls"])
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1"
 export const PATH = "/chat/completions"
 
@@ -194,6 +194,7 @@ 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),
@@ -709,6 +710,7 @@ 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))
@@ -728,7 +730,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     else if (
       reasoningDetailsObserved &&
       !lifecycle.reasoning.has("reasoning-0") &&
-      (Boolean(delta?.content) || toolDeltas.length > 0)
+      (Boolean(delta?.content) || Boolean(delta?.refusal) || toolDeltas.length > 0)
     )
       lifecycle = Lifecycle.reasoningStart(lifecycle, events, "reasoning-0", deltaMetadata)
     const reasoningEmitted = state.reasoningEmitted || lifecycle.reasoning.has("reasoning-0")
@@ -743,6 +745,16 @@ 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()) {

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

@@ -42,6 +42,8 @@ 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)),

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

@@ -47,9 +47,17 @@ 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)),

packages/ai/src/provider-package.ts

@@ -1,62 +1,16 @@
-import { Auth } from "./route/auth.js"
-import type { AuthOverride, RequiredApiKeyAuth } from "./route/auth-options.js"
 import type { LanguageModel, ProviderOptions } from "./schema/index.js"
 
-export interface Settings {}
-
-export type Credential =
-  | {
-      readonly type: "key"
-      readonly value: string
-      readonly configuration?: Readonly<Record<string, unknown>>
-    }
-  | {
-      readonly type: "oauth"
-      readonly accessToken: string
-    }
-
-export interface Defaults {
+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 ModelInput<ProviderSettings extends Settings = Settings> {
-  readonly id: string
-  readonly settings: ProviderSettings
-  readonly credential?: Credential
-  readonly defaults: Defaults
-}
-
-export const routeDefaults = (input: Defaults) => ({
-  headers: input.headers,
-  http: input.body === undefined ? undefined : { body: input.body },
-  limits: input.limits,
-})
-
-export const bearerCredentialValue = (input: Credential) => (input.type === "key" ? input.value : input.accessToken)
-
-export const bearerAuthOption = (input: Credential): AuthOverride => ({
-  auth: Auth.bearer(bearerCredentialValue(input)),
-})
-
-export const apiKeyOrBearerAuthOption = (
-  input: Credential,
-  competingKeyHeader: string,
-): RequiredApiKeyAuth | AuthOverride =>
-  input.type === "key"
-    ? { apiKey: input.value }
-    : { auth: Auth.remove(competingKeyHeader).andThen(Auth.bearer(input.accessToken)) }
-
 export interface Definition<
   ProviderSettings extends Settings = Settings,
   Options extends ProviderOptions = ProviderOptions,
 > {
-  readonly model: (input: ModelInput<ProviderSettings>) => LanguageModel<Options>
+  readonly model: (modelID: string, settings: ProviderSettings) => LanguageModel<Options>
 }
 
 export * as ProviderPackage from "./provider-package.js"

packages/ai/src/providers/amazon-bedrock-mantle.ts

@@ -1,6 +1,6 @@
 import { Auth } from "../route/auth.js"
 import type { Route as RouteDef, RouteDefaultsInput } from "../route/client.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { OpenAIChat } from "../protocols/openai-chat.js"
 import { OpenAIResponses } from "../protocols/openai-responses.js"
 import { BedrockAuth, type Credentials } from "../protocols/utils/bedrock-auth.js"
@@ -79,27 +79,28 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
-  if (!input.credential && input.settings.auth === "bearer" && input.settings.apiKey === undefined)
+const config = (settings: Settings): Config => {
+  if (settings.auth === "bearer" && settings.apiKey === undefined)
     throw new Error("Amazon Bedrock Mantle bearer auth requires apiKey")
-  if (!input.credential && input.settings.auth === "sigv4" && input.settings.apiKey !== undefined)
+  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock Mantle SigV4 auth does not accept apiKey")
   return {
-    ...ProviderPackage.routeDefaults(input.defaults),
-    apiKey: input.credential
-      ? ProviderPackage.bearerCredentialValue(input.credential)
-      : input.settings.auth === "sigv4"
-        ? undefined
-        : input.settings.apiKey,
-    baseURL: input.settings.baseURL,
-    credentials: input.settings.credentials,
-    providerOptions: input.settings.providerOptions,
-    region: input.settings.region,
+    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
+    baseURL: settings.baseURL,
+    credentials: settings.credentials,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+    region: settings.region,
   }
 }
 
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
-  configure(config(input)).chat(input.id)
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
-  configure(config(input)).responses(input.id)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).chat(modelID)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).responses(modelID)
 export const model = chatModel

packages/ai/src/providers/amazon-bedrock.ts

@@ -1,6 +1,6 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as BedrockConverse from "../protocols/bedrock-converse.js"
 import type { BedrockCredentials } from "../protocols/bedrock-converse.js"
@@ -50,21 +50,18 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (input) => {
-  if (!input.credential && input.settings.auth === "bearer" && input.settings.apiKey === undefined)
+export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+  if (settings.auth === "bearer" && settings.apiKey === undefined)
     throw new Error("Amazon Bedrock bearer auth requires apiKey")
-  if (!input.credential && input.settings.auth === "sigv4" && input.settings.apiKey !== undefined)
+  if (settings.auth === "sigv4" && settings.apiKey !== undefined)
     throw new Error("Amazon Bedrock SigV4 auth does not accept apiKey")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    apiKey: input.credential
-      ? ProviderPackage.bearerCredentialValue(input.credential)
-      : input.settings.auth === "sigv4"
-        ? undefined
-        : input.settings.apiKey,
-    baseURL: input.settings.baseURL,
-    credentials: input.settings.credentials,
-    generation: input.settings.topP === undefined ? undefined : { topP: input.settings.topP },
-    region: input.settings.region,
-  }).model(input.id)
+    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
+    baseURL: settings.baseURL,
+    credentials: settings.credentials,
+    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    region: settings.region,
+  }).model(modelID)
 }

packages/ai/src/providers/anthropic-compatible.ts

@@ -1,4 +1,4 @@
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
@@ -32,9 +32,7 @@ export const routes = [AnthropicMessages.route]
 
 const auth = (input: ProviderAuthOption<"optional">) => {
   if ("auth" in input && input.auth) return input.auth
-  return Auth.remove("authorization").andThen(
-    Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key")),
-  )
+  return Auth.optional("apiKey" in input ? input.apiKey : undefined, "apiKey").pipe(Auth.header("x-api-key"))
 }
 
 export const configure = (input: Config) => {
@@ -59,20 +57,20 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
-  if (!input.credential && input.settings.apiKey !== undefined && input.settings.authToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => {
+  if (settings.apiKey !== undefined && settings.authToken !== undefined)
     throw new Error("Anthropic-compatible apiKey cannot be combined with authToken")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential
-      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-api-key")
-      : input.settings.authToken === undefined
-        ? { apiKey: input.settings.apiKey }
-        : { auth: Auth.bearer(input.settings.authToken) }),
-    baseURL: input.settings.baseURL,
-    provider: input.settings.provider,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }
 
 export * as AnthropicCompatible from "./anthropic-compatible.js"

packages/ai/src/providers/anthropic.ts

@@ -1,7 +1,7 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { AnthropicCompatible } from "./anthropic-compatible.js"
@@ -31,11 +31,9 @@ export type Settings = ProviderPackage.Settings &
 
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
-  return Auth.remove("authorization").andThen(
-    Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-      .orElse(Auth.config("ANTHROPIC_API_KEY"))
-      .pipe(Auth.header("x-api-key")),
-  )
+  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+    .orElse(Auth.config("ANTHROPIC_API_KEY"))
+    .pipe(Auth.header("x-api-key"))
 }
 
 export const configure = (input: Config = {}) => {
@@ -54,17 +52,17 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
-  if (!input.credential && input.settings.apiKey !== undefined && input.settings.authToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => {
+  if (settings.apiKey !== undefined && settings.authToken !== undefined)
     throw new Error("Anthropic apiKey cannot be combined with authToken")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential
-      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-api-key")
-      : input.settings.authToken === undefined
-        ? { apiKey: input.settings.apiKey }
-        : { auth: Auth.bearer(input.settings.authToken) }),
-    baseURL: input.settings.baseURL,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    ...(settings.authToken === undefined ? { apiKey: settings.apiKey } : { auth: Auth.bearer(settings.authToken) }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }

packages/ai/src/providers/azure.ts

@@ -1,7 +1,7 @@
 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"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
@@ -120,29 +120,27 @@ export const provider = {
   configure,
 }
 
-const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
-  const settings = input.settings
-  const configuration = input.credential?.type === "key" ? input.credential.configuration : undefined
-  const baseURL = settings.baseURL ?? (typeof configuration?.baseURL === "string" ? configuration.baseURL : undefined)
-  const resourceName =
-    settings.resourceName ?? (typeof configuration?.resourceName === "string" ? configuration.resourceName : undefined)
+const config = (settings: Settings): Config => {
   const common = {
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential
-      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "api-key")
-      : { apiKey: settings.apiKey }),
+    apiKey: settings.apiKey,
     apiVersion: settings.apiVersion,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
     providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
     useDeploymentBasedUrls: settings.useDeploymentBasedUrls,
   }
-  if (baseURL !== undefined) return { ...common, baseURL }
-  if (resourceName !== undefined) return { ...common, resourceName }
+  if (settings.baseURL !== undefined) return { ...common, baseURL: settings.baseURL }
+  if (settings.resourceName !== undefined) return { ...common, resourceName: settings.resourceName }
   throw new Error("Azure requires resourceName or baseURL")
 }
 
-export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
-  configure(config(input)).responses(input.id)
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
-  configure(config(input)).chat(input.id)
+export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).responses(modelID)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).chat(modelID)
 export const model = responsesModel

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

@@ -1,4 +1,4 @@
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
@@ -68,15 +68,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) => {
-  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
-    throw new Error("Google Vertex Chat does not support API keys")
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Chat does not support API keys")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
-    baseURL: input.settings.baseURL,
-    location: input.settings.location,
-    project: input.settings.project,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }

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

@@ -1,5 +1,5 @@
 import { Effect, Schema, Struct } from "effect"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { AnthropicMessages } from "../protocols/anthropic-messages.js"
 import { Auth } from "../route/auth.js"
 import { Route, type RouteDefaultsInput } from "../route/client.js"
@@ -100,15 +100,18 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (input) => {
-  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
-    throw new Error("Google Vertex Messages does not support API keys")
+export const model: ProviderPackage.Definition<Settings, AnthropicMessages.ProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => {
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Messages does not support API keys")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
-    baseURL: input.settings.baseURL,
-    location: input.settings.location,
-    project: input.settings.project,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }

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

@@ -1,4 +1,4 @@
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { ProviderID, type ModelID } from "../schema/index.js"
@@ -70,15 +70,18 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (input) => {
-  if (input.credential?.type === "key" || (!input.credential && input.settings.apiKey !== undefined))
-    throw new Error("Google Vertex Responses does not support API keys")
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => {
+  if (settings.apiKey !== undefined) throw new Error("Google Vertex Responses does not support API keys")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    accessToken: input.credential?.type === "oauth" ? input.credential.accessToken : input.settings.accessToken,
-    baseURL: input.settings.baseURL,
-    location: input.settings.location,
-    project: input.settings.project,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    accessToken: settings.accessToken,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }

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

@@ -69,8 +69,9 @@ const adc = (project?: string) => {
 export const oauth = (input: OAuthOptions, project?: string) => {
   if (input.accessToken !== undefined && input.auth !== undefined)
     throw new Error("Google Vertex accessToken cannot be combined with auth")
-  const auth = input.auth ?? (input.accessToken !== undefined ? Auth.bearer(input.accessToken) : adc(project))
-  return Auth.remove("x-goog-api-key").andThen(auth)
+  if (input.auth) return input.auth
+  if (input.accessToken !== undefined) return Auth.bearer(input.accessToken)
+  return adc(project)
 }
 
 export * as GoogleVertexShared from "./google-vertex-shared.js"

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

@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { Gemini } from "../protocols/gemini.js"
 import { ProviderShared } from "../protocols/shared.js"
 import { Auth } from "../route/auth.js"
@@ -94,10 +94,7 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
   return route.with({
     ...rest,
     endpoint: { baseURL: endpoint },
-    auth:
-      apiKey === undefined
-        ? GoogleVertexShared.oauth(input, project)
-        : Auth.remove("authorization").andThen(Auth.header("x-goog-api-key", apiKey)),
+    auth: apiKey === undefined ? GoogleVertexShared.oauth(input, project) : Auth.header("x-goog-api-key", apiKey),
   })
 }
 
@@ -114,21 +111,16 @@ export const provider = {
   id,
   configure,
 }
-export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (input) => {
-  if (!input.credential && input.settings.apiKey !== undefined && input.settings.accessToken !== undefined)
+export const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"] = (modelID, settings) => {
+  if (settings.apiKey !== undefined && settings.accessToken !== undefined)
     throw new Error("Google Vertex apiKey cannot be combined with accessToken or auth")
   return configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential
-      ? input.credential.type === "key"
-        ? { apiKey: input.credential.value }
-        : { accessToken: input.credential.accessToken }
-      : input.settings.apiKey === undefined
-        ? { accessToken: input.settings.accessToken }
-        : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    location: input.settings.location,
-    project: input.settings.project,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    ...(settings.apiKey === undefined ? { accessToken: settings.accessToken } : { apiKey: settings.apiKey }),
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    location: settings.location,
+    project: settings.project,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 }

packages/ai/src/providers/google.ts

@@ -1,7 +1,7 @@
 import type { RouteDefaultsInput } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import type { ProviderAuthOption } from "../route/auth-options.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import { Gemini } from "../protocols/gemini.js"
 import { GoogleImages } from "../protocols/google-images.js"
@@ -28,11 +28,9 @@ export interface Settings extends ProviderPackage.Settings {
 
 const auth = (options: ProviderAuthOption<"optional">) => {
   if ("auth" in options && options.auth) return options.auth
-  return Auth.remove("authorization").andThen(
-    Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
-      .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
-      .pipe(Auth.header("x-goog-api-key")),
-  )
+  return Auth.optional("apiKey" in options ? options.apiKey : undefined, "apiKey")
+    .orElse(Auth.config("GOOGLE_GENERATIVE_AI_API_KEY"))
+    .pipe(Auth.header("x-goog-api-key"))
 }
 
 const configuredRoute = (input: Config) => {
@@ -59,14 +57,13 @@ export const configure = (input: Config = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (input) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential
-      ? ProviderPackage.apiKeyOrBearerAuthOption(input.credential, "x-goog-api-key")
-      : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 
 export const image = provider.image

packages/ai/src/providers/openai-compatible-responses.ts

@@ -1,4 +1,4 @@
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { RouteDefaultsInput } from "../route/client.js"
@@ -46,11 +46,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (input) =>
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) =>
   configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    provider: input.settings.provider,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)

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

@@ -2,7 +2,7 @@ import { ProviderID, type ModelID } from "../schema/index.js"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat.js"
 import type { RouteDefaultsInput } from "../route/client.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile.js"
 import type { OpenAIProviderOptionsInput } from "./openai-options.js"
 
@@ -68,14 +68,15 @@ export const provider = {
   configure,
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    provider: input.settings.provider,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    provider: settings.provider,
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 
 export const baseten = define(profiles.baseten)
 export const cerebras = define(profiles.cerebras)

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

@@ -1,21 +1,37 @@
 import { mergeProviderOptions, type ProviderOptions } from "../schema/index.js"
 import type { OpenResponsesOptionsInput } from "./open-responses-options.js"
-import type { Options } from "../protocols/utils/open-responses-options.js"
 
 export type { OpenAIResponseIncludable, OpenAIServiceTier } from "../protocols/utils/openai-options.js"
 
 export type OpenAIOptionsInput = OpenResponsesOptionsInput
-export type OpenAIConfigOptions = Options
 
 export type OpenAIProviderOptionsInput = OpenAIOptionsInput
 
+const definedEntries = (input: Record<string, unknown>) =>
+  Object.entries(input).filter((entry) => entry[1] !== undefined)
+
+const openAIProviderOptions = (options: OpenAIOptionsInput | undefined): ProviderOptions | undefined => {
+  const result = Object.fromEntries(
+    definedEntries({
+      store: options?.store,
+      reasoningEffort: options?.reasoningEffort,
+      reasoningSummary: options?.reasoningSummary,
+      include: options?.include,
+      textVerbosity: options?.textVerbosity,
+      serviceTier: options?.serviceTier,
+    }),
+  )
+  if (Object.keys(result).length === 0) return undefined
+  return result
+}
+
 export const gpt5DefaultOptions = (
   modelID: string,
   options: { readonly textVerbosity?: boolean } = {},
 ): ProviderOptions | undefined => {
   const id = modelID.toLowerCase()
   if (!id.includes("gpt-5") || id.includes("gpt-5-chat") || id.includes("gpt-5-pro")) return undefined
-  return {
+  return openAIProviderOptions({
     reasoningEffort: "medium",
     reasoningSummary: "auto",
     // GPT-5 reasoning models are configured stateless (`store: false`) by
@@ -28,13 +44,14 @@ export const gpt5DefaultOptions = (
       options.textVerbosity === true && id.includes("gpt-5.") && !id.includes("codex") && !id.includes("-chat")
         ? "low"
         : undefined,
-  }
+  })
 }
 
 export const openAIDefaultOptions = (
   modelID: string,
   options: { readonly textVerbosity?: boolean } = {},
-): ProviderOptions | undefined => mergeProviderOptions({ store: false }, gpt5DefaultOptions(modelID, options))
+): ProviderOptions | undefined =>
+  mergeProviderOptions(openAIProviderOptions({ store: false }), gpt5DefaultOptions(modelID, options))
 
 export const withOpenAIOptions = <Options extends { readonly providerOptions?: OpenAIProviderOptionsInput }>(
   modelID: string,

packages/ai/src/providers/openai.ts

@@ -1,10 +1,10 @@
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import type { Route, RouteDefaultsInput } from "../route/client.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import { HttpOptions, ProviderID, ToolDefinition, mergeHttpOptions, type ModelID } from "../schema/index.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
-import { withOpenAIOptions, type OpenAIConfigOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
+import { withOpenAIOptions, type OpenAIProviderOptionsInput } from "./openai-options.js"
 import { OpenAIImages, type OpenAIImageString } from "../protocols/openai-images.js"
 
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options.js"
@@ -17,11 +17,11 @@ export const routes = [OpenAIResponses.route, OpenAIChat.route]
 // This provider facade wraps the lower-level Responses and Chat model factories
 // with OpenAI-specific conveniences: typed options, API-key sugar, env fallback,
 // and default option normalization.
-export type Config = Omit<RouteDefaultsInput, "providerOptions"> &
-  OpenAIConfigOptions &
+export type Config = RouteDefaultsInput &
   ProviderAuthOption<"optional"> & {
     readonly baseURL?: string
     readonly queryParams?: Record<string, string>
+    readonly providerOptions?: OpenAIProviderOptionsInput
   }
 
 export interface ImageGenerationOptions {
@@ -57,12 +57,13 @@ export const imageGeneration = (options: ImageGenerationOptions = {}) =>
     },
   })
 
-export interface Settings extends ProviderPackage.Settings, OpenAIConfigOptions {
+export interface Settings extends ProviderPackage.Settings {
   readonly apiKey?: string
   readonly baseURL?: string
   readonly organization?: string
   readonly project?: string
   readonly queryParams?: Readonly<Record<string, string>>
+  readonly providerOptions?: OpenAIProviderOptionsInput
 }
 
 const auth = (options: ProviderAuthOption<"optional">) => AuthOptions.bearer(options, "OPENAI_API_KEY")
@@ -72,39 +73,6 @@ const defaults = (input: Config) => {
   return rest
 }
 
-const splitConfigOptions = <Input extends OpenAIConfigOptions>(input: Input) => {
-  const {
-    instructions,
-    store,
-    reasoningEffort,
-    reasoningSummary,
-    include,
-    textVerbosity,
-    serviceTier,
-    truncation,
-    allowedTools,
-    maxToolCalls,
-    parallelToolCalls,
-    ...rest
-  } = input
-  return {
-    options: {
-      instructions,
-      store,
-      reasoningEffort,
-      reasoningSummary,
-      include,
-      textVerbosity,
-      serviceTier,
-      truncation,
-      allowedTools,
-      maxToolCalls,
-      parallelToolCalls,
-    },
-    rest,
-  }
-}
-
 const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Config) =>
   route.with({
     auth: auth(input),
@@ -114,8 +82,7 @@ const configuredRoute = <Body, Prepared>(route: Route<Body, Prepared>, input: Co
 export const configure = (input: Config = {}) => {
   const responsesRoute = configuredRoute(OpenAIResponses.route, input)
   const chatRoute = configuredRoute(OpenAIChat.route, input)
-  const split = splitConfigOptions(defaults(input))
-  const modelDefaults = { ...split.rest, providerOptions: split.options }
+  const modelDefaults = defaults(input)
   const responses = (id: string | ModelID) =>
     responsesRoute
       .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
@@ -146,30 +113,30 @@ export const configure = (input: Config = {}) => {
 
 export const provider = configure()
 
-const config = (input: ProviderPackage.ModelInput<Settings>): Config => {
-  const settings = input.settings
-  const options = splitConfigOptions(settings).options
+const config = (settings: Settings): Config => {
   const headers = {
     ...(settings.organization === undefined ? {} : { "OpenAI-Organization": settings.organization }),
     ...(settings.project === undefined ? {} : { "OpenAI-Project": settings.project }),
-    ...input.defaults.headers,
+    ...settings.headers,
   }
   return {
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: settings.apiKey }),
+    apiKey: settings.apiKey,
     baseURL: settings.baseURL,
     headers: Object.keys(headers).length === 0 ? undefined : headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
     queryParams: settings.queryParams === undefined ? undefined : { ...settings.queryParams },
-    ...options,
   }
 }
 
-export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) => {
-  return configure(config(input)).responses(input.id)
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
+  return configure(config(settings)).responses(modelID)
 }
 
-export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (input) =>
-  configure(config(input)).chat(input.id)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).chat(modelID)
 export const responses = provider.responses
 export const chat = provider.chat
 export const image = provider.image

packages/ai/src/providers/openrouter.ts

@@ -5,7 +5,7 @@ import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 import * as OpenAICompatibleProfiles from "./openai-compatible-profile.js"
 import * as OpenAIChat from "../protocols/openai-chat.js"
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js"
@@ -191,10 +191,14 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (input) =>
+export const model: ProviderPackage.Definition<Settings, OpenRouterProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) =>
   configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)

packages/ai/src/providers/xai.ts

@@ -8,7 +8,7 @@ import * as OpenAIChat from "../protocols/openai-chat.js"
 import * as OpenAIResponses from "../protocols/openai-responses.js"
 import { XAIImages } from "../protocols/xai-images.js"
 import type { OpenAIOptionsInput } from "./openai-options.js"
-import { ProviderPackage } from "../provider-package.js"
+import type { ProviderPackage } from "../provider-package.js"
 
 export const id = ProviderID.make("xai")
 
@@ -95,13 +95,14 @@ export const configure = (input: LanguageModelOptions = {}) => {
 }
 
 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (input) =>
+export const model: ProviderPackage.Definition<Settings, XAIProviderOptionsInput>["model"] = (modelID, settings) =>
   configure({
-    ...ProviderPackage.routeDefaults(input.defaults),
-    ...(input.credential ? ProviderPackage.bearerAuthOption(input.credential) : { apiKey: input.settings.apiKey }),
-    baseURL: input.settings.baseURL,
-    providerOptions: input.settings.providerOptions,
-  }).model(input.id)
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers,
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
 export const responses = provider.responses
 export const chat = provider.chat
 export const image = provider.image

packages/ai/src/route/client.ts

@@ -16,7 +16,6 @@ import {
   LLMRequest,
   LLMResponse,
   LanguageModel,
-  LanguageModelLimits,
   LLMEvent,
   InvalidProviderOutputReason,
   ProviderID,
@@ -74,7 +73,6 @@ 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
@@ -82,7 +80,6 @@ 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
@@ -119,7 +116,6 @@ 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(

packages/ai/src/schema/options.ts

@@ -114,22 +114,7 @@ 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),
@@ -139,7 +124,6 @@ export namespace LanguageModelDefaults {
   export type Input =
     | LanguageModelDefaults
     | {
-        readonly limits?: LanguageModelLimits.Input
         readonly generation?: GenerationOptions.Input
         readonly providerOptions?: ProviderOptions
         readonly http?: HttpOptions.Input
@@ -149,7 +133,6 @@ 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),

packages/ai/test/auth-options.types.ts

@@ -81,22 +81,8 @@ OpenAI.configure({
 }).responses("gpt-4.1-mini")
 OpenAI.configure({
   generation: { maxTokens: 100 },
-  store: false,
+  providerOptions: { store: false },
 }).responses("gpt-4.1-mini")
-OpenAI.model({
-  id: "gpt-5",
-  settings: {},
-  credential: { type: "key", value: "sk-test" },
-  defaults: { headers: { "x-test": "value" } },
-})
-OpenAI.model({
-  id: "gpt-5",
-  settings: {
-    // @ts-expect-error Common request defaults belong under input.defaults.
-    headers: { "x-test": "value" },
-  },
-  defaults: {},
-})
 
 // @ts-expect-error OpenAI model selectors only accept model ids.
 OpenAI.configure({ apiKey: "sk-test" }).responses("gpt-4.1-mini", {})
@@ -111,7 +97,7 @@ OpenAI.configure({ bogus: true })
 OpenAI.configure({ generation: { maxTokens: "many" } })
 
 // @ts-expect-error provider-native options remain typed.
-OpenAI.configure({ store: "false" })
+OpenAI.configure({ providerOptions: { store: "false" } })
 
 // @ts-expect-error auth is an override, so OpenAI rejects apiKey with auth.
 OpenAI.configure({ apiKey: "sk-test", auth: Auth.bearer("oauth-token") })
@@ -159,12 +145,8 @@ Anthropic.configure({
 }).model("claude-haiku")
 // @ts-expect-error Anthropic model selectors only accept model ids.
 Anthropic.configure({ apiKey: "anthropic-key" }).model("claude-haiku", {})
-Anthropic.model({
-  id: "claude-sonnet-4-6",
-  // @ts-expect-error Anthropic package settings accept only one auth source.
-  settings: { apiKey: "anthropic-key", authToken: "anthropic-token" },
-  defaults: {},
-})
+// @ts-expect-error Anthropic package settings accept only one auth source.
+Anthropic.model("claude-sonnet-4-6", { apiKey: "anthropic-key", authToken: "anthropic-token" })
 // @ts-expect-error Enabled Anthropic thinking requires a token budget.
 Anthropic.configure({ providerOptions: { thinking: { type: "enabled" } } })
 // @ts-expect-error Anthropic thinking budgets must be numbers.
@@ -180,15 +162,11 @@ AnthropicCompatible.configure({
 AnthropicCompatible.configure({ apiKey: "messages-key" })
 // @ts-expect-error Anthropic-compatible model selectors only accept model ids.
 AnthropicCompatible.configure({ baseURL: "https://messages.example.com/v1" }).model("compatible-model", {})
-AnthropicCompatible.model({
-  id: "compatible-model",
-  // @ts-expect-error Anthropic-compatible package settings accept only one auth source.
-  settings: {
-    apiKey: "messages-key",
-    authToken: "messages-token",
-    baseURL: "https://messages.example.com/v1",
-  },
-  defaults: {},
+// @ts-expect-error Anthropic-compatible package settings accept only one auth source.
+AnthropicCompatible.model("compatible-model", {
+  apiKey: "messages-key",
+  authToken: "messages-token",
+  baseURL: "https://messages.example.com/v1",
 })
 
 Google.configure({ apiKey: "google-key" }).model("gemini-2.5-flash")
@@ -211,23 +189,15 @@ GoogleVertex.configure({ auth: Auth.bearer("vertex-token"), project: "project" }
 GoogleVertex.configure({ apiKey: "vertex-key" }).model("gemini-3.5-flash", {})
 // @ts-expect-error Vertex Gemini config accepts only one auth source.
 GoogleVertex.configure({ accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
-GoogleVertex.model({
-  id: "gemini-3.5-flash",
-  // @ts-expect-error Vertex Gemini package settings accept only one auth source.
-  settings: { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" },
-  defaults: {},
-})
+// @ts-expect-error Vertex Gemini package settings accept only one auth source.
+GoogleVertex.model("gemini-3.5-flash", { accessToken: "vertex-token", apiKey: "vertex-key", project: "project" })
 
 GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model("deepseek-ai/deepseek-v3.2-maas")
 GoogleVertexChat.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
   "deepseek-ai/deepseek-v3.2-maas",
 )
-GoogleVertexChat.model({
-  id: "deepseek-ai/deepseek-v3.2-maas",
-  // @ts-expect-error Vertex Chat package settings do not accept API keys.
-  settings: { apiKey: "vertex-key", project: "project" },
-  defaults: {},
-})
+// @ts-expect-error Vertex Chat package settings do not accept API keys.
+GoogleVertexChat.model("deepseek-ai/deepseek-v3.2-maas", { apiKey: "vertex-key", project: "project" })
 GoogleVertexChat.configure({ accessToken: "vertex-token", project: "project" }).model(
   "deepseek-ai/deepseek-v3.2-maas",
   // @ts-expect-error Vertex Chat model selectors only accept model ids.
@@ -244,12 +214,8 @@ GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project
 GoogleVertexResponses.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model(
   "xai/grok-4.20-reasoning",
 )
-GoogleVertexResponses.model({
-  id: "xai/grok-4.20-reasoning",
-  // @ts-expect-error Vertex Responses package settings do not accept API keys.
-  settings: { apiKey: "vertex-key", project: "project" },
-  defaults: {},
-})
+// @ts-expect-error Vertex Responses package settings do not accept API keys.
+GoogleVertexResponses.model("xai/grok-4.20-reasoning", { apiKey: "vertex-key", project: "project" })
 GoogleVertexResponses.configure({ accessToken: "vertex-token", project: "project" }).model(
   "xai/grok-4.20-reasoning",
   // @ts-expect-error Vertex Responses model selectors only accept model ids.
@@ -267,12 +233,8 @@ GoogleVertexMessages.configure({
   project: "project",
   providerOptions: { thinking: { type: "adaptive", display: "omitted" }, effort: "low" },
 }).model("claude-sonnet-4-6")
-GoogleVertexMessages.model({
-  id: "claude-sonnet-4-6",
-  // @ts-expect-error Vertex Messages package settings do not accept API keys.
-  settings: { apiKey: "vertex-key", project: "project" },
-  defaults: {},
-})
+// @ts-expect-error Vertex Messages package settings do not accept API keys.
+GoogleVertexMessages.model("claude-sonnet-4-6", { apiKey: "vertex-key", project: "project" })
 GoogleVertexMessages.configure({ auth: Auth.bearer("vertex-token"), project: "project" }).model("claude-sonnet-4-6")
 GoogleVertexMessages.configure({ accessToken: "vertex-token", project: "project" }).model(
   "claude-sonnet-4-6",

packages/ai/test/compile.test.ts

@@ -270,21 +270,20 @@ describe("request option precedence", () => {
     ),
   )
 
-  it.effect("uses model output limits after route limits and before call maxTokens", () =>
+  it.effect("uses the Anthropic default 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", defaults: { limits: { output: 64 } } })
+      const model = route.model({ id: "claude-sonnet-4-5" })
       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: 32 } }),
+        LLM.request({ model, prompt: "Say hello.", cache: "none", generation: { maxTokens: 8_000 } }),
       )
 
-      expect(withoutMaxTokens.body.max_tokens).toBe(64)
-      expect(withMaxTokens.body.max_tokens).toBe(32)
+      expect(withoutMaxTokens.body.max_tokens).toBe(32_000)
+      expect(withMaxTokens.body.max_tokens).toBe(8_000)
     }),
   )
 })

packages/ai/test/llm.test.ts

@@ -121,7 +121,6 @@ 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 } },
@@ -130,7 +129,6 @@ 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 } })

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

@@ -1,72 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { ConfigProvider, Effect } from "effect"
-import { Headers } from "effect/unstable/http"
-import { LLM, ProviderPackage } from "@opencode-ai/ai"
 import { model } from "@opencode-ai/ai/providers/openai"
 
-const packageInput = <Input extends Record<string, unknown>>(id: string, input: Input) => {
-  const { headers, body, limits, ...settings } = input
-  return { id, settings, defaults: { headers, body, limits } }
-}
-
-const authHeaders = (
-  selected: ReturnType<typeof model>,
-  headers: Record<string, string> = {},
-  env: Record<string, string> = {},
-) =>
-  Effect.runPromise(
-    selected.route.auth
-      .apply({
-        request: LLM.request({ model: selected, prompt: "hello" }),
-        method: "POST",
-        url: "https://example.test/v1",
-        body: "{}",
-        headers: Headers.fromInput(headers),
-      })
-      .pipe(Effect.provide(ConfigProvider.layer(ConfigProvider.fromEnv({ env })))),
-  )
-
-const applyAuth = (
-  option: ReturnType<typeof ProviderPackage.bearerAuthOption>,
-  headers: Record<string, string> = {},
-) => {
-  const selected = model(packageInput("gpt-5", { apiKey: "fixture" }))
-  return Effect.runPromise(
-    option.auth.apply({
-      request: LLM.request({ model: selected, prompt: "hello" }),
-      method: "POST",
-      url: "https://example.test/v1",
-      body: "{}",
-      headers: Headers.fromInput(headers),
-    }),
-  )
-}
-
-describe("provider package credential lowering", () => {
-  test("intentionally renders keys and OAuth credentials as bearer auth", async () => {
-    const key = await applyAuth(ProviderPackage.bearerAuthOption({ type: "key", value: "provider-key" }))
-    const oauth = await applyAuth(ProviderPackage.bearerAuthOption({ type: "oauth", accessToken: "provider-token" }))
-
-    expect(key.authorization).toBe("Bearer provider-key")
-    expect(oauth.authorization).toBe("Bearer provider-token")
-  })
-
-  test("keeps key-header credentials configurable and removes stale keys for OAuth", async () => {
-    expect(ProviderPackage.apiKeyOrBearerAuthOption({ type: "key", value: "provider-key" }, "x-api-key")).toEqual({
-      apiKey: "provider-key",
-    })
-    const oauth = ProviderPackage.apiKeyOrBearerAuthOption(
-      { type: "oauth", accessToken: "provider-token" },
-      "x-api-key",
-    )
-    if (!("auth" in oauth)) throw new Error("Expected OAuth credential to lower to auth")
-    const headers = await applyAuth(oauth, { "x-api-key": "stale" })
-
-    expect(headers.authorization).toBe("Bearer provider-token")
-    expect(headers["x-api-key"]).toBeUndefined()
-  })
-})
-
 describe("provider package entrypoints", () => {
   test("semantic API aliases expose the same contract", async () => {
     const modules = await Promise.all([
@@ -109,177 +43,49 @@ 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(
-      packageInput("anthropic/claude-sonnet-4", {
-        ...settings,
-        providerOptions: { usage: true },
-      }),
-    )
-    const xai = XAI.model(
-      packageInput("grok-4", {
-        ...settings,
-        providerOptions: { reasoningEffort: "high" },
-      }),
-    )
+    const openrouter = OpenRouter.model("anthropic/claude-sonnet-4", {
+      ...settings,
+      providerOptions: { usage: true },
+    })
+    const xai = XAI.model("grok-4", {
+      ...settings,
+      providerOptions: { reasoningEffort: "high" },
+    })
 
     for (const selected of [openrouter, xai]) {
       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 })
   })
 
   test("maps package settings onto the executable model", () => {
-    const selected = model(
-      packageInput("gpt-5", {
-        apiKey: "fixture",
-        baseURL: "https://api.openai.test/v1",
-        headers: { "x-application": "opencode" },
-        body: { service_tier: "priority" },
-        limits: { context: 200_000, output: 64_000 },
-        reasoningEffort: "high",
-        unrelatedInheritedSetting: true,
-      }),
-    )
+    const selected = model("gpt-5", {
+      apiKey: "fixture",
+      baseURL: "https://api.openai.test/v1",
+      headers: { "x-application": "opencode" },
+      body: { service_tier: "priority" },
+      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 })
-    expect(selected.route.defaults.providerOptions).toEqual({
-      store: false,
-      reasoningEffort: "high",
-      reasoningSummary: "auto",
-      include: ["reasoning.encrypted_content"],
-    })
-  })
-
-  test("lets provider packages interpret resolved credentials", async () => {
-    const Anthropic = await import("@opencode-ai/ai/providers/anthropic")
-    const Azure = await import("@opencode-ai/ai/providers/azure")
-    const Google = await import("@opencode-ai/ai/providers/google")
-    const GoogleVertex = await import("@opencode-ai/ai/providers/google-vertex")
-    const GoogleVertexChat = await import("@opencode-ai/ai/providers/google-vertex/chat")
-    const openai = model({
-      id: "gpt-5",
-      settings: {},
-      credential: { type: "oauth", accessToken: "openai-token" },
-      defaults: {},
-    })
-    const anthropicKey = Anthropic.model({
-      id: "claude-sonnet-4-6",
-      settings: {},
-      credential: { type: "key", value: "anthropic-key" },
-      defaults: {},
-    })
-    const anthropicOAuth = Anthropic.model({
-      id: "claude-sonnet-4-6",
-      settings: {},
-      credential: { type: "oauth", accessToken: "anthropic-token" },
-      defaults: {},
-    })
-    const anthropicEmptyKey = Anthropic.model({
-      id: "claude-sonnet-4-6",
-      settings: {},
-      credential: { type: "key", value: "" },
-      defaults: {},
-    })
-    const azureKey = Azure.model({
-      id: "deployment",
-      settings: { resourceName: "opencode-test" },
-      credential: { type: "key", value: "azure-key" },
-      defaults: {},
-    })
-    const azureOAuth = Azure.model({
-      id: "deployment",
-      settings: { resourceName: "opencode-test" },
-      credential: { type: "oauth", accessToken: "azure-token" },
-      defaults: {},
-    })
-    const googleKey = Google.model({
-      id: "gemini-2.5-flash",
-      settings: {},
-      credential: { type: "key", value: "google-key" },
-      defaults: {},
-    })
-    const googleOAuth = Google.model({
-      id: "gemini-2.5-flash",
-      settings: {},
-      credential: { type: "oauth", accessToken: "google-token" },
-      defaults: {},
-    })
-    const vertexKey = GoogleVertex.model({
-      id: "gemini-3.5-flash",
-      settings: {},
-      credential: { type: "key", value: "vertex-key" },
-      defaults: {},
-    })
-    const vertexOAuth = GoogleVertex.model({
-      id: "gemini-3.5-flash",
-      settings: { project: "vertex-project" },
-      credential: { type: "oauth", accessToken: "vertex-token" },
-      defaults: {},
-    })
-    const vertexChatOAuth = GoogleVertexChat.model({
-      id: "deepseek-ai/deepseek-v3.2-maas",
-      settings: { apiKey: "configured-key", project: "vertex-project" },
-      credential: { type: "oauth", accessToken: "vertex-chat-token" },
-      defaults: {},
-    })
-
-    expect((await authHeaders(openai)).authorization).toBe("Bearer openai-token")
-    const anthropicKeyHeaders = await authHeaders(anthropicKey, { authorization: "Bearer stale" })
-    const anthropicOAuthHeaders = await authHeaders(anthropicOAuth, { "x-api-key": "stale" })
-    const anthropicEmptyKeyHeaders = await authHeaders(
-      anthropicEmptyKey,
-      { authorization: "Bearer stale" },
-      { ANTHROPIC_API_KEY: "environment-key" },
-    )
-    const azureKeyHeaders = await authHeaders(azureKey, { authorization: "Bearer stale" })
-    const azureOAuthHeaders = await authHeaders(azureOAuth, { "api-key": "stale" })
-    const googleKeyHeaders = await authHeaders(googleKey, { authorization: "Bearer stale" })
-    const googleOAuthHeaders = await authHeaders(googleOAuth, { "x-goog-api-key": "stale" })
-    const vertexKeyHeaders = await authHeaders(vertexKey, { authorization: "Bearer stale" })
-    const vertexOAuthHeaders = await authHeaders(vertexOAuth, { "x-goog-api-key": "stale" })
-    expect(anthropicKeyHeaders["x-api-key"]).toBe("anthropic-key")
-    expect(anthropicKeyHeaders.authorization).toBeUndefined()
-    expect(anthropicOAuthHeaders.authorization).toBe("Bearer anthropic-token")
-    expect(anthropicOAuthHeaders["x-api-key"]).toBeUndefined()
-    expect(anthropicEmptyKeyHeaders["x-api-key"]).toBe("environment-key")
-    expect(anthropicEmptyKeyHeaders.authorization).toBeUndefined()
-    expect(azureKeyHeaders["api-key"]).toBe("azure-key")
-    expect(azureKeyHeaders.authorization).toBeUndefined()
-    expect(azureOAuthHeaders.authorization).toBe("Bearer azure-token")
-    expect(azureOAuthHeaders["api-key"]).toBeUndefined()
-    expect(googleKeyHeaders["x-goog-api-key"]).toBe("google-key")
-    expect(googleKeyHeaders.authorization).toBeUndefined()
-    expect(googleOAuthHeaders.authorization).toBe("Bearer google-token")
-    expect(googleOAuthHeaders["x-goog-api-key"]).toBeUndefined()
-    expect(vertexKeyHeaders["x-goog-api-key"]).toBe("vertex-key")
-    expect(vertexKeyHeaders.authorization).toBeUndefined()
-    expect(vertexOAuthHeaders.authorization).toBe("Bearer vertex-token")
-    expect(vertexOAuthHeaders["x-goog-api-key"]).toBeUndefined()
-    expect((await authHeaders(vertexChatOAuth)).authorization).toBe("Bearer vertex-chat-token")
   })
 
   test("maps OpenAI-compatible Responses settings onto the executable model", async () => {
     const OpenAICompatibleResponses = await import("@opencode-ai/ai/providers/openai-compatible/responses")
-    const selected = OpenAICompatibleResponses.model(
-      packageInput("custom-model", {
-        apiKey: "fixture",
-        baseURL: "https://responses.example.test/v1",
-        provider: "example",
-        headers: { "x-application": "opencode" },
-        body: { service_tier: "priority" },
-        limits: { context: 200_000, output: 64_000 },
-        providerOptions: { reasoningEffort: "low", store: true },
-      }),
-    )
+    const selected = OpenAICompatibleResponses.model("custom-model", {
+      apiKey: "fixture",
+      baseURL: "https://responses.example.test/v1",
+      provider: "example",
+      headers: { "x-application": "opencode" },
+      body: { service_tier: "priority" },
+      providerOptions: { reasoningEffort: "low", store: true },
+    })
 
     expect(String(selected.provider)).toBe("example")
     expect(selected.route.id).toBe("openai-compatible-responses")
@@ -289,23 +95,19 @@ 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 })
   })
 
   test("maps Anthropic-compatible settings onto the executable model", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
-    const selected = AnthropicCompatible.model(
-      packageInput("compatible-model", {
-        apiKey: "fixture",
-        baseURL: "https://messages.example.test/v1",
-        provider: "example",
-        headers: { "x-application": "opencode" },
-        body: { metadata: { user_id: "user_1" } },
-        limits: { context: 200_000, output: 64_000 },
-        providerOptions: { effort: "low" },
-      }),
-    )
+    const selected = AnthropicCompatible.model("compatible-model", {
+      apiKey: "fixture",
+      baseURL: "https://messages.example.test/v1",
+      provider: "example",
+      headers: { "x-application": "opencode" },
+      body: { metadata: { user_id: "user_1" } },
+      providerOptions: { effort: "low" },
+    })
 
     expect(String(selected.provider)).toBe("example")
     expect(selected.route.id).toBe("anthropic-messages")
@@ -315,18 +117,15 @@ 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" })
   })
 
   test("maps Anthropic provider options onto the executable model", async () => {
     const Anthropic = await import("@opencode-ai/ai/providers/anthropic")
-    const selected = Anthropic.model(
-      packageInput("claude-sonnet-4-6", {
-        apiKey: "fixture",
-        providerOptions: { thinking: { type: "adaptive" } },
-      }),
-    )
+    const selected = Anthropic.model("claude-sonnet-4-6", {
+      apiKey: "fixture",
+      providerOptions: { thinking: { type: "adaptive" } },
+    })
 
     expect(selected.route.defaults.providerOptions).toEqual({ thinking: { type: "adaptive" } })
   })
@@ -334,7 +133,7 @@ describe("provider package entrypoints", () => {
   test("requires an Anthropic-compatible base URL at runtime", async () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     expect(() =>
-      Reflect.apply(AnthropicCompatible.model, undefined, [packageInput("compatible-model", { apiKey: "fixture" })]),
+      Reflect.apply(AnthropicCompatible.model, undefined, ["compatible-model", { apiKey: "fixture" }]),
     ).toThrow("Anthropic-compatible providers require a baseURL")
   })
 
@@ -343,28 +142,25 @@ describe("provider package entrypoints", () => {
     const AnthropicCompatible = await import("@opencode-ai/ai/providers/anthropic-compatible")
     expect(() =>
       Reflect.apply(AnthropicCompatible.model, undefined, [
-        packageInput("compatible-model", {
+        "compatible-model",
+        {
           apiKey: "fixture",
           authToken: "token",
           baseURL: "https://messages.example.test/v1",
-        }),
+        },
       ]),
     ).toThrow("Anthropic-compatible apiKey cannot be combined with authToken")
     expect(() =>
-      Reflect.apply(Anthropic.model, undefined, [
-        packageInput("claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }),
-      ]),
+      Reflect.apply(Anthropic.model, undefined, ["claude-sonnet-4-6", { apiKey: "fixture", authToken: "token" }]),
     ).toThrow("Anthropic apiKey cannot be combined with authToken")
   })
 
   test("maps legacy OpenAI organization and project settings to headers", () => {
-    const selected = model(
-      packageInput("gpt-5", {
-        apiKey: "fixture",
-        organization: "org_123",
-        project: "proj_123",
-      }),
-    )
+    const selected = model("gpt-5", {
+      apiKey: "fixture",
+      organization: "org_123",
+      project: "proj_123",
+    })
 
     expect(selected.route.defaults.headers).toMatchObject({
       "OpenAI-Organization": "org_123",
@@ -381,37 +177,31 @@ 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(packageInput("deployment", settings))
-    const chat = AzureChat.model(packageInput("deployment", settings))
+    const responses = AzureResponses.model("deployment", settings)
+    const chat = AzureChat.model("deployment", settings)
 
-    expect(Azure.model(packageInput("deployment", settings)).route.id).toBe("azure-openai-responses")
+    expect(Azure.model("deployment", settings).route.id).toBe("azure-openai-responses")
     expect(responses.route.id).toBe("azure-openai-responses")
     expect(responses.route.endpoint.baseURL).toBe("https://opencode-test.openai.azure.com/openai/v1")
     expect(responses.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(responses.route.defaults.http?.body).toEqual({ service_tier: "priority" })
-    expect(responses.route.defaults.limits).toEqual({ context: 200_000, output: 64_000 })
     expect(chat.route.id).toBe("azure-openai-chat")
   })
 
   test("constructs Azure deployment URLs and preserves custom gateway URLs", async () => {
     const Azure = await import("@opencode-ai/ai/providers/azure")
-    const deployment = Azure.model(
-      packageInput("custom-deployment", {
-        apiKey: "fixture",
-        resourceName: "opencode-test",
-        apiVersion: "2025-01-01-preview",
-        useDeploymentBasedUrls: true,
-      }),
-    )
-    const gateway = Azure.model(
-      packageInput("gateway-model", {
-        apiKey: "fixture",
-        baseURL: "https://gateway.example/azure/",
-      }),
-    )
+    const deployment = Azure.model("custom-deployment", {
+      apiKey: "fixture",
+      resourceName: "opencode-test",
+      apiVersion: "2025-01-01-preview",
+      useDeploymentBasedUrls: true,
+    })
+    const gateway = Azure.model("gateway-model", {
+      apiKey: "fixture",
+      baseURL: "https://gateway.example/azure/",
+    })
 
     expect(deployment.route.endpoint).toMatchObject({
       baseURL: "https://opencode-test.openai.azure.com/openai/deployments/custom-deployment",
@@ -423,22 +213,18 @@ describe("provider package entrypoints", () => {
 
   test("maps Google package settings onto the Gemini model", async () => {
     const Google = await import("@opencode-ai/ai/providers/google")
-    const selected = Google.model(
-      packageInput("gemini-2.5-flash", {
-        apiKey: "fixture",
-        baseURL: "https://generativelanguage.test/v1beta",
-        headers: { "x-application": "opencode" },
-        body: { safetySettings: [] },
-        limits: { context: 1_000_000, output: 65_536 },
-        providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
-      }),
-    )
+    const selected = Google.model("gemini-2.5-flash", {
+      apiKey: "fixture",
+      baseURL: "https://generativelanguage.test/v1beta",
+      headers: { "x-application": "opencode" },
+      body: { safetySettings: [] },
+      providerOptions: { thinkingConfig: { thinkingBudget: 1_024 } },
+    })
 
     expect(selected.route.id).toBe("gemini")
     expect(selected.route.endpoint.baseURL).toBe("https://generativelanguage.test/v1beta")
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(selected.route.defaults.http?.body).toEqual({ safetySettings: [] })
-    expect(selected.route.defaults.limits).toEqual({ context: 1_000_000, output: 65_536 })
     expect(selected.route.defaults.providerOptions).toEqual({ thinkingConfig: { thinkingBudget: 1_024 } })
   })
 
@@ -448,35 +234,26 @@ describe("provider package entrypoints", () => {
     const GoogleVertexChat = await import("@opencode-ai/ai/providers/google-vertex/chat")
     const GoogleVertexResponses = await import("@opencode-ai/ai/providers/google-vertex/responses")
     const GoogleVertexMessages = await import("@opencode-ai/ai/providers/google-vertex/messages")
-    const gemini = GoogleVertex.model(
-      packageInput("gemini-3.5-flash", {
-        apiKey: "fixture",
-        headers: { "x-application": "opencode" },
-        body: { safetySettings: [] },
-        limits: { context: 1_000_000, output: 65_536 },
-      }),
-    )
-    const messages = GoogleVertexMessages.model(
-      packageInput("claude-sonnet-4-6", {
-        accessToken: "fixture",
-        location: "global",
-        project: "vertex-project",
-      }),
-    )
-    const chat = GoogleVertexChat.model(
-      packageInput("deepseek-ai/deepseek-v3.2-maas", {
-        accessToken: "fixture",
-        location: "global",
-        project: "vertex-project",
-      }),
-    )
-    const responses = GoogleVertexResponses.model(
-      packageInput("xai/grok-4.20-reasoning", {
-        accessToken: "fixture",
-        location: "global",
-        project: "vertex-project",
-      }),
-    )
+    const gemini = GoogleVertex.model("gemini-3.5-flash", {
+      apiKey: "fixture",
+      headers: { "x-application": "opencode" },
+      body: { safetySettings: [] },
+    })
+    const messages = GoogleVertexMessages.model("claude-sonnet-4-6", {
+      accessToken: "fixture",
+      location: "global",
+      project: "vertex-project",
+    })
+    const chat = GoogleVertexChat.model("deepseek-ai/deepseek-v3.2-maas", {
+      accessToken: "fixture",
+      location: "global",
+      project: "vertex-project",
+    })
+    const responses = GoogleVertexResponses.model("xai/grok-4.20-reasoning", {
+      accessToken: "fixture",
+      location: "global",
+      project: "vertex-project",
+    })
 
     expect(GoogleVertexGemini.model).toBe(GoogleVertex.model)
     expect(gemini.route.id).toBe("google-vertex-gemini")
@@ -484,15 +261,12 @@ 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(
-        packageInput("gemini-3.5-flash", {
-          accessToken: "fixture",
-          location: "eu",
-          project: "vertex-project",
-        }),
-      ).route.endpoint.baseURL,
+      GoogleVertex.model("gemini-3.5-flash", {
+        accessToken: "fixture",
+        location: "eu",
+        project: "vertex-project",
+      }).route.endpoint.baseURL,
     ).toBe("https://aiplatform.eu.rep.googleapis.com/v1beta1/projects/vertex-project/locations/eu/publishers/google")
     expect(messages.route.id).toBe("google-vertex-messages")
     expect(messages.route.protocol).toBe("anthropic-messages")
@@ -522,11 +296,8 @@ describe("provider package entrypoints", () => {
     const Providers = await import("@opencode-ai/ai/providers")
     expect(() =>
       Reflect.apply(GoogleVertex.model, undefined, [
-        packageInput("gemini-3.5-flash", {
-          accessToken: "token",
-          apiKey: "fixture",
-          project: "vertex-project",
-        }),
+        "gemini-3.5-flash",
+        { accessToken: "token", apiKey: "fixture", project: "vertex-project" },
       ]),
     ).toThrow("Google Vertex apiKey cannot be combined with accessToken or auth")
     const configured = Reflect.apply(GoogleVertex.configure, undefined, [
@@ -535,7 +306,8 @@ describe("provider package entrypoints", () => {
     expect(() => configured.model("gemini-3.5-flash")).toThrow("Google Vertex accessToken cannot be combined with auth")
     expect(() =>
       Reflect.apply(GoogleVertexMessages.model, undefined, [
-        packageInput("claude-sonnet-4-6", { apiKey: "fixture", project: "vertex-project" }),
+        "claude-sonnet-4-6",
+        { apiKey: "fixture", project: "vertex-project" },
       ]),
     ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
@@ -545,7 +317,8 @@ describe("provider package entrypoints", () => {
     ).toThrow("Google Vertex Messages does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexChat.model, undefined, [
-        packageInput("deepseek-ai/deepseek-v3.2-maas", { apiKey: "fixture", project: "vertex-project" }),
+        "deepseek-ai/deepseek-v3.2-maas",
+        { apiKey: "fixture", project: "vertex-project" },
       ]),
     ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
@@ -555,7 +328,8 @@ describe("provider package entrypoints", () => {
     ).toThrow("Google Vertex Chat does not support API keys")
     expect(() =>
       Reflect.apply(GoogleVertexResponses.model, undefined, [
-        packageInput("xai/grok-4.20-reasoning", { apiKey: "fixture", project: "vertex-project" }),
+        "xai/grok-4.20-reasoning",
+        { apiKey: "fixture", project: "vertex-project" },
       ]),
     ).toThrow("Google Vertex Responses does not support API keys")
     expect(() =>

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

@@ -322,7 +322,7 @@ describe("Anthropic Messages route", () => {
           { role: "user", content: [{ type: "tool_result", tool_use_id: "call_1", content: '{"forecast":"sunny"}' }] },
         ],
         stream: true,
-        max_tokens: 4096,
+        max_tokens: 32_000,
       })
     }),
   )

packages/ai/test/provider/gemini.test.ts

@@ -139,6 +139,48 @@ 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("prepares multimodal user input and tool history", () =>
     Effect.gen(function* () {
       const prepared = yield* compileRequest(

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

@@ -664,6 +664,74 @@ 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

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

@@ -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." },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
       ])
     }),
   )
@@ -113,11 +113,67 @@ describe("Open Responses-compatible route", () => {
       )
 
       expect(prepared.body).toMatchObject({
-        input: [{ role: "assistant", content: [{ type: "output_text", text: "Unclassified." }] }],
+        input: [{ type: "message", 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({
@@ -126,6 +182,10 @@ 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,
@@ -136,6 +196,7 @@ 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" } })],
         }),
       )
@@ -143,6 +204,12 @@ 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",

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

@@ -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." },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
       ])
     }),
   )
@@ -485,7 +485,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("continues store-false reasoning without replaying the output-only item ID", () =>
+  it.effect("continues store-false reasoning while retaining the output 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,6 +515,7 @@ describe("OpenAI Responses route", () => {
           ...firstInput,
           {
             type: "reasoning",
+            id: "rs_1",
             summary: [{ type: "summary_text", text: "Thought" }],
             encrypted_content: "encrypted",
           },
@@ -1284,6 +1285,7 @@ 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" } }),
@@ -1293,6 +1295,10 @@ 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,
@@ -1306,6 +1312,12 @@ 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",
@@ -1473,7 +1485,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" },
+        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         { type: "text-delta", id: "msg_1", text: "Hello" },
         { type: "text-delta", id: "msg_1", text: "!" },
         { type: "text-end", id: "msg_1" },
@@ -1494,6 +1506,108 @@ 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(
@@ -1532,33 +1646,39 @@ describe("OpenAI Responses route", () => {
         {
           type: "text",
           text: "Checking.",
-          providerMetadata: { openai: { phase: "commentary" } },
+          providerMetadata: { openai: { itemId: "msg_commentary", phase: "commentary" } },
         },
         {
           type: "text",
           text: "Finished.",
-          providerMetadata: { openai: { phase: "final_answer" } },
+          providerMetadata: { openai: { itemId: "msg_final", phase: "final_answer" } },
         },
         {
           type: "text",
           text: "Unclassified.",
-          providerMetadata: { openai: { phase: null } },
+          providerMetadata: { openai: { itemId: "msg_null", 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,
@@ -1652,12 +1772,12 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(response.events.filter((event) => event.type.startsWith("text-"))).toEqual([
-        { type: "text-start", id: "msg_1" },
+        { type: "text-start", id: "msg_1", providerMetadata: { openai: { itemId: "msg_1" } } },
         { type: "text-delta", id: "msg_1", text: "First" },
-        { type: "text-end", id: "msg_1" },
-        { type: "text-start", id: "msg_2" },
+        { type: "text-end", id: "msg_1", providerMetadata: undefined },
+        { type: "text-start", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
         { type: "text-delta", id: "msg_2", text: "Second" },
-        { type: "text-end", id: "msg_2" },
+        { type: "text-end", id: "msg_2", providerMetadata: { openai: { itemId: "msg_2" } } },
       ])
     }),
   )
@@ -1689,7 +1809,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" },
+        { type: "text", text: "Hello", providerMetadata: { openai: { itemId: "msg_1" } } },
       ])
     }),
   )
@@ -1850,6 +1970,7 @@ 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." }],
                   },
@@ -1857,7 +1978,6 @@ 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." },
@@ -1901,13 +2021,14 @@ describe("OpenAI Responses route", () => {
       )
 
       expect(prepared.body.input).toEqual([
-        { role: "assistant", content: [{ type: "output_text", text: "Before." }] },
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "Before." }] },
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [{ type: "summary_text", text: "Checked order." }],
         },
-        { role: "assistant", content: [{ type: "output_text", text: "After." }] },
+        { type: "message", role: "assistant", content: [{ type: "output_text", text: "After." }] },
       ])
     }),
   )
@@ -2039,6 +2160,7 @@ describe("OpenAI Responses route", () => {
       expect(prepared.body.input).toEqual([
         {
           type: "reasoning",
+          id: "rs_1",
           encrypted_content: "encrypted-state",
           summary: [
             { type: "summary_text", text: "First" },
@@ -2171,6 +2293,50 @@ 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")
     }),
   )
 
@@ -2237,6 +2403,35 @@ 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 = {

packages/app/e2e/performance/README.md

@@ -2,12 +2,34 @@
 
 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

packages/app/e2e/performance/chrome-trace.ts

@@ -18,9 +18,9 @@ const categories = [
   "disabled-by-default-v8.cpu_profiler",
 ]
 
-export async function startChromeTrace(page: Page, name: string) {
+export async function startChromeTrace(page: Page, name: string): Promise<undefined | (() => Promise<string>)> {
   const directory = process.env.OPENCODE_PERFORMANCE_TRACE_DIR
-  if (!directory) return
+  if (!directory) return undefined
 
   const selectors = process.env.OPENCODE_PERFORMANCE_SELECTOR_TRACE === "1"
   const file = await prepareChromeTrace(directory, name, selectors)

packages/app/e2e/performance/devex/desktop-startup-benchmark.spec.ts

@@ -0,0 +1,26 @@
+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)
+  })
+})

packages/app/e2e/performance/devex/desktop-startup.ts

@@ -0,0 +1,526 @@
+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
+}

packages/app/e2e/performance/devex/playwright.config.ts

@@ -0,0 +1,17 @@
+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" }],
+})

packages/app/e2e/performance/playwright.config.ts

@@ -7,7 +7,7 @@ process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(
 export default {
   ...config,
   testDir: ".",
-  testIgnore: "unit/**",
+  testIgnore: ["unit/**", "devex/**"],
   outputDir: "../test-results/performance",
   fullyParallel: false,
   workers: 1,

packages/app/e2e/performance/timeline-stability/adverse.spec.ts

@@ -179,7 +179,7 @@ test.describe("timeline adverse visual stability", () => {
         userMessage(),
         assistantMessage([
           shell(shellID, "completed", wideLines(15)),
-          toolPart(contextIDs[0]!, "read", "completed", { filePath: "src/a.ts" }),
+          toolPart(contextIDs[0]!, "read", "completed", { path: "src/a.ts" }),
           toolPart(contextIDs[1]!, "glob", "completed", { path: ".", pattern: "**/*.ts" }),
           textPart(followingID, "Following responsive timeline content that wraps on narrow screens."),
         ]),

packages/app/e2e/performance/timeline-stability/file-matrix.spec.ts

@@ -1,4 +1,5 @@
 import { test } from "@playwright/test"
+import { createTwoFilesPatch } from "diff"
 import {
   defineVisualRegions,
   reportVisualStability,
@@ -18,16 +19,20 @@ import {
 } from "./fixture"
 
 const profiles = [
-  { name: "edit", tool: "edit", input: { filePath: "src/edit.ts" } },
+  {
+    name: "edit",
+    tool: "edit",
+    input: { path: "src/edit.ts", oldString: "export const value = 1", newString: "export const value = 2" },
+  },
   {
     name: "multi patch",
-    tool: "apply_patch",
-    input: { files: ["src/a.ts", "src/b.ts", "src/old.ts", "src/moved.ts"] },
+    tool: "patch",
+    input: { patchText: "Update generated files" },
   },
 ] as const
 
 for (const profile of profiles) {
-  test(`stabilizes ${profile.name} pending to completed`, async ({ page }, testInfo) => {
+  test(`stabilizes ${profile.name} streaming 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, {
@@ -35,7 +40,7 @@ for (const profile of profiles) {
         userMessage(),
         assistantMessage(
           [
-            toolPart(partID, profile.tool, "pending", profile.input),
+            toolPart(partID, profile.tool, "streaming", profile.input),
             textPart(followingID, `Following ${profile.name}`),
           ],
           { completed: false },
@@ -89,34 +94,27 @@ function completedPart(partID: string, profile: (typeof profiles)[number]) {
   if (profile.tool === "edit") {
     return toolPart(partID, profile.tool, "completed", profile.input, {
       metadata: {
-        filediff: {
-          file: "src/edit.ts",
-          additions: 50,
-          deletions: 50,
-          before: source(50, false),
-          after: source(50, true),
-        },
+        files: [patchFile("src/edit.ts", "modified", 50)],
       },
     })
   }
   const files = [
-    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" },
+    patchFile("src/a.ts", "modified", 20),
+    patchFile("src/b.ts", "added", 20),
+    patchFile("src/old.ts", "deleted", 20),
   ]
   return toolPart(partID, profile.tool, "completed", profile.input, { metadata: { files } })
 }
 
-function patchFile(filePath: string, type: "add" | "update" | "delete" | "move") {
+function patchFile(file: string, status: "added" | "modified" | "deleted", lines: number) {
+  const before = status === "added" ? "" : source(lines, false)
+  const after = status === "deleted" ? "" : source(lines, true)
   return {
-    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),
+    file,
+    status,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    additions: status === "deleted" ? 0 : lines,
+    deletions: status === "added" ? 0 : lines,
   }
 }
 

packages/app/e2e/performance/timeline-stability/file-mutation.spec.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test"
+import { createTwoFilesPatch } from "diff"
 import {
   defineVisualRegions,
   reportVisualStability,
@@ -20,13 +21,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", "update")
+  const first = patchFile("src/a.ts", "modified")
   const timeline = await setupTimeline(page, {
     messages: [
       userMessage(),
       assistantMessage(
         [
-          toolPart(patchID, "apply_patch", "running", { files: [first.filePath] }, { metadata: { files: [first] } }),
+          toolPart(patchID, "patch", "running", { patchText: "Update files" }, { metadata: { files: [first] } }),
           textPart(followingID, "Following incremental patch"),
         ],
         { completed: false },
@@ -55,15 +56,15 @@ test("adds patch files incrementally without resetting outer expansion", async (
     },
   })
   await startVisualProbe(page, regions)
-  const second = patchFile("src/b.ts", "add")
-  const third = patchFile("src/old.ts", "delete")
+  const second = patchFile("src/b.ts", "added")
+  const third = patchFile("src/old.ts", "deleted")
   await timeline.send(
     partUpdated(
       toolPart(
         patchID,
-        "apply_patch",
+        "patch",
         "running",
-        { files: [first.filePath, second.filePath] },
+        { patchText: "Update files" },
         { metadata: { files: [first, second] } },
       ),
     ),
@@ -73,9 +74,9 @@ test("adds patch files incrementally without resetting outer expansion", async (
     partUpdated(
       toolPart(
         patchID,
-        "apply_patch",
+        "patch",
         "completed",
-        { files: [first.filePath, second.filePath, third.filePath] },
+        { patchText: "Update files" },
         { metadata: { files: [first, second, third] } },
       ),
     ),
@@ -106,15 +107,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(filePath: string, type: "add" | "update" | "delete") {
+function patchFile(file: string, status: "added" | "modified" | "deleted") {
+  const before = status === "added" ? "" : source(false)
+  const after = status === "deleted" ? "" : source(true)
   return {
-    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),
+    file,
+    status,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    additions: status === "deleted" ? 0 : 4,
+    deletions: status === "added" ? 0 : 3,
   }
 }
 

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

@@ -35,7 +35,7 @@ describe("timeline fixture validation", () => {
         userMessage(),
         {
           ...assistantMessage(),
-          content: [{ type: "tool", id: "call_invalid", name: "bash", state: { status: "completed" } }],
+          content: [{ type: "tool", id: "call_invalid", name: "shell", state: { status: "completed" } }],
         } as never,
       ]),
     ).toThrow()
@@ -60,12 +60,11 @@ 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 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 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 error fields are not valid after completion.
-  toolPart("prt_invalid_completed", "bash", "completed", {}, { error: "impossible" })
+  toolPart("prt_invalid_completed", "shell", "completed", {}, { error: "impossible" })
 
   assistantMessage([
     // @ts-expect-error Agent references belong to user messages, not assistant messages.

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

@@ -60,17 +60,17 @@ type ReasoningSeed = {
 type ToolSeed = {
   id: string
   type: "tool"
-  callID: string
-  tool: string
+  name: string
   messageID?: string
   executed?: boolean
   providerState?: Record<string, unknown>
   providerResultState?: Record<string, unknown>
   state:
-    | { status: "pending"; input: Record<string, unknown>; raw: string }
+    | { status: "streaming"; 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 "pending"
+type ToolOptions<State extends ToolStatus> = State extends "streaming"
   ? { output?: never; title?: never; metadata?: never; error?: never }
   : State extends "running"
-    ? { title?: string; metadata?: Record<string, unknown>; output?: never; error?: never }
+    ? { title?: string; metadata?: Record<string, unknown>; output?: string; 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,6 +371,15 @@ 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
         ? []
@@ -542,9 +551,9 @@ export function reasoningPart(id: string, text: string): ReasoningSeed {
 export function toolPart(
   id: string,
   tool: string,
-  state: "pending",
+  state: "streaming",
   input: Record<string, unknown>,
-  options?: ToolOptions<"pending">,
+  options?: ToolOptions<"streaming">,
 ): ToolSeed
 export function toolPart(
   id: string,
@@ -574,14 +583,15 @@ export function toolPart(
   input: Record<string, unknown>,
   options: ToolOptions<ToolStatus> = {},
 ): ToolSeed {
-  const base = { id, type: "tool" as const, callID: id, tool }
-  if (state === "pending") return { ...base, state: { status: state, input, raw: "" } }
+  const base = { id, type: "tool" as const, name: tool }
+  if (state === "streaming") 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 },
@@ -612,12 +622,10 @@ export function toolPart(
 }
 
 export function shell(id: string, state: ToolStatus, output = "", command = `echo ${id}`): ToolSeed {
-  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 } })
+  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 })
 }
 
 export function completedAssistantInfo(info: SessionMessageAssistant): SessionMessageAssistant {
@@ -655,7 +663,7 @@ function messageContent(
 ): SessionMessageAssistant["content"][number] {
   if (part.type === "tool") {
     partRefs.set(part.id, { messageID, type: part.type })
-    toolStates.set(part.callID, part.state.status)
+    toolStates.set(part.id, part.state.status)
   } else {
     partRefs.set(part.id, { messageID, type: part.type, ordinal: ordinals[part.type]++ })
     startedParts.add(part.id)
@@ -675,8 +683,8 @@ function messageContent(
   const completed = state.status === "completed" || state.status === "error" ? state.time.end : undefined
   const base = {
     type: "tool" as const,
-    id: part.callID,
-    name: part.tool,
+    id: part.id,
+    name: part.name,
     time: {
       created: time?.start ?? 1700000001000,
       ...(time?.start === undefined ? {} : { ran: time.start }),
@@ -686,11 +694,18 @@ function messageContent(
     ...(part.providerState ? { providerState: jsonRecord(part.providerState) } : {}),
     ...(part.providerResultState ? { providerResultState: jsonRecord(part.providerResultState) } : {}),
   }
-  if (state.status === "pending") return { ...base, state: { status: "streaming", input: state.raw } }
+  if (state.status === "streaming") 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: {
+        status: "running",
+        input: jsonRecord(state.input),
+        metadata: jsonRecord({
+          ...state.metadata,
+          ...(state.output === undefined ? {} : { output: state.output }),
+        }),
+      },
     }
   if (state.status === "error")
     return {
@@ -714,7 +729,7 @@ function messageContent(
 }
 
 function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[] {
-  const previous = toolStates.get(part.callID)
+  const previous = toolStates.get(part.id)
   if (previous === "completed" || previous === "error") return []
 
   const events: OpenCodeEvent[] = []
@@ -723,27 +738,27 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
       makeEvent("session.tool.input.started", {
         sessionID,
         assistantMessageID: messageID,
-        id: part.callID,
-        name: part.tool,
+        id: part.id,
+        name: part.name,
       }),
     )
   }
-  if (part.state.status === "pending") {
-    toolStates.set(part.callID, part.state.status)
+  if (part.state.status === "streaming") {
+    toolStates.set(part.id, part.state.status)
     return events
   }
-  if (!previous || previous === "pending") {
+  if (!previous || previous === "streaming") {
     events.push(
       makeEvent("session.tool.input.ended", {
         sessionID,
         assistantMessageID: messageID,
-        id: part.callID,
+        id: part.id,
         text: JSON.stringify(part.state.input),
       }),
       makeEvent("session.tool.called", {
         sessionID,
         assistantMessageID: messageID,
-        id: part.callID,
+        id: part.id,
         input: part.state.input,
         executed: part.executed ?? true,
         state: jsonRecord(part.providerState),
@@ -751,16 +766,20 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
     )
   }
   if (part.state.status === "running") {
-    if (previous === "running" || Object.keys(part.state.metadata).length)
+    const metadata = {
+      ...part.state.metadata,
+      ...(part.state.output === undefined ? {} : { output: part.state.output }),
+    }
+    if (previous === "running" || Object.keys(metadata).length)
       events.push(
         makeEvent("session.tool.progress", {
           sessionID,
           assistantMessageID: messageID,
-          id: part.callID,
-          metadata: jsonRecord(part.state.metadata),
+          id: part.id,
+          metadata: jsonRecord(metadata),
         }),
       )
-    toolStates.set(part.callID, part.state.status)
+    toolStates.set(part.id, part.state.status)
     return events
   }
   if (part.state.status === "error") {
@@ -768,28 +787,28 @@ function toolEvents(part: ToolSeed, messageID: string): readonly OpenCodeEvent[]
       makeEvent("session.tool.failed", {
         sessionID,
         assistantMessageID: messageID,
-        id: part.callID,
+        id: part.id,
         error: { type: "ToolError", message: part.state.error },
         metadata: jsonRecord(part.state.metadata),
         executed: part.executed ?? true,
         resultState: jsonRecord(part.providerResultState),
       }),
     )
-    toolStates.set(part.callID, part.state.status)
+    toolStates.set(part.id, part.state.status)
     return events
   }
   events.push(
     makeEvent("session.tool.success", {
       sessionID,
       assistantMessageID: messageID,
-      id: part.callID,
+      id: part.id,
       content: [{ type: "text", text: part.state.output }],
       metadata: jsonRecord(part.state.metadata),
       executed: part.executed ?? true,
       resultState: jsonRecord(part.providerResultState),
     }),
   )
-  toolStates.set(part.callID, part.state.status)
+  toolStates.set(part.id, part.state.status)
   return events
 }
 

packages/app/e2e/performance/timeline-stability/interaction.spec.ts

@@ -1,4 +1,5 @@
 import { expect, test } from "@playwright/test"
+import { createTwoFilesPatch } from "diff"
 import {
   defineVisualRegions,
   reportVisualStability,
@@ -58,14 +59,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 page.waitForTimeout(500)
+  await waitForVisualSettle(page, [regions.shell.selector, regions.following.selector])
   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 page.waitForTimeout(500)
+  await waitForVisualSettle(page, [regions.shell.selector, regions.following.selector])
   const collapsed = await stopVisualProbe<keyof typeof regions>(page)
   await reportVisualStability(testInfo, "shell-collapse", collapsed, plan)
 })
@@ -83,7 +84,7 @@ test("expands and collapses a completed context group without overlap", async ({
     messages: [
       userMessage(),
       assistantMessage([
-        toolPart(ids[0]!, "read", "completed", { filePath: "src/a.ts" }),
+        toolPart(ids[0]!, "read", "completed", { path: "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" }),
@@ -110,7 +111,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 page.waitForTimeout(500)
+    await waitForVisualSettle(page, [regions.context.selector, regions.following.selector])
     const trace = await stopVisualProbe<keyof typeof regions>(page)
     await reportVisualStability(
       testInfo,
@@ -142,16 +143,23 @@ test("expands and collapses an edit diff without moving twice", async ({ page },
           editID,
           "edit",
           "completed",
-          { filePath: "src/edit.ts" },
+          { path: "src/edit.ts", oldString: "export const value = 1", newString: "export const value = 2" },
           {
             metadata: {
-              filediff: {
-                file: "src/edit.ts",
-                additions: 40,
-                deletions: 40,
-                before: source(40, false),
-                after: source(40, true),
-              },
+              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",
+                },
+              ],
             },
           },
         ),
@@ -182,7 +190,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 page.waitForTimeout(900)
+  await waitForVisualSettle(page, [regions.edit.selector, regions.following.selector])
   const trace = await stopVisualProbe<keyof typeof regions>(page)
   await reportVisualStability(
     testInfo,

packages/app/e2e/performance/timeline-stability/tool-mutation.spec.ts

@@ -17,32 +17,32 @@ import {
   userMessage,
 } from "./fixture"
 
-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" }
+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." }
   const timeline = await setupTimeline(page, {
-    messages: [userMessage(), assistantMessage([toolPart(taskID, "task", "running", input)], { completed: false })],
+    messages: [userMessage(), assistantMessage([toolPart(taskID, "subagent", "running", input)], { completed: false })],
     sessions: [session(), session({ id: childID, parentID: sessionID, title: "Inspect child" })],
     cpuRate: 4,
   })
   const regions = defineVisualRegions({
-    task: { selector: `[data-timeline-part-id="${renderedPartID(taskID)}"] [data-slot="collapsible-trigger"]` },
+    subagent: { selector: `[data-timeline-part-id="${renderedPartID(taskID)}"] [data-slot="collapsible-trigger"]` },
   })
   await startVisualProbe(page, regions)
   await timeline.send(
-    partUpdated(toolPart(taskID, "task", "completed", input, { metadata: { sessionId: childID } })),
+    partUpdated(toolPart(taskID, "subagent", "completed", input, { metadata: { sessionID: childID } })),
     500,
   )
   const trace = await stopVisualProbe<keyof typeof regions>(page)
   await reportVisualStability(
     testInfo,
-    "task-link",
+    "subagent-link",
     trace,
     visualPlan(regions, [
-      { type: "required", regions: ["task"] },
-      { type: "unique", regions: ["task"] },
-      { type: "stable", regions: ["task"] },
+      { type: "required", regions: ["subagent"] },
+      { type: "unique", regions: ["subagent"] },
+      { type: "stable", regions: ["subagent"] },
       { type: "opacity", regions: "all" },
       { type: "continuity", regions: "all" },
       { type: "motion", regions: "all", maxPositionReversals: 0 },

packages/app/e2e/performance/timeline-stability/tools.spec.ts

@@ -21,24 +21,30 @@ import {
 } from "./fixture"
 
 test.describe("timeline tool state stability", () => {
-  test("moves lightweight tools through pending, running, and completed without replacing rows", async ({
+  test("moves lightweight tools through streaming, running, and completed without replacing rows", async ({
     page,
   }, testInfo) => {
-    const ids = ["webfetch", "websearch", "task", "skill", "custom"] as const
+    const ids = ["webfetch", "websearch", "subagent", "skill", "custom"] as const
     const inputs = {
       webfetch: { url: "https://example.com/docs" },
       websearch: { query: "timeline stability" },
-      task: { description: "Inspect timeline", subagent_type: "explore" },
+      subagent: { description: "Inspect timeline", agent: "explore", prompt: "Inspect the timeline." },
       skill: { name: "stability" },
       custom: { target: "timeline", depth: 2 },
     }
-    const names = { webfetch: "webfetch", websearch: "websearch", task: "task", skill: "skill", custom: "mcp_probe" }
+    const names = {
+      webfetch: "webfetch",
+      websearch: "websearch",
+      subagent: "subagent",
+      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], "pending", inputs[id])),
-      toolPart(questionID, "question", "pending", questionInput()),
-      toolPart(todoID, "todowrite", "pending", { todos: [{ content: "Hidden", status: "pending" }] }),
+      ...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" }] }),
       textPart("prt_state_following", "Following lightweight tools"),
     ]
     const childID = "ses_timeline_child"
@@ -55,14 +61,14 @@ test.describe("timeline tool state stability", () => {
     const regionIDs = [
       "prt_state_webfetch",
       "prt_state_websearch",
-      "prt_state_task",
+      "prt_state_subagent",
       "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_task: toolRegion(regionIDs[2]),
+      prt_state_subagent: toolRegion(regionIDs[2]),
       prt_state_skill: toolRegion(regionIDs[3]),
       prt_state_custom: toolRegion(regionIDs[4]),
     })
@@ -73,9 +79,9 @@ test.describe("timeline tool state stability", () => {
         [80, 240, 100, 360, 140][index],
       )
     }
-    for (const [index, id] of ["skill", "webfetch", "custom", "task", "websearch"].entries()) {
+    for (const [index, id] of ["skill", "webfetch", "custom", "subagent", "websearch"].entries()) {
       const key = id as (typeof ids)[number]
-      const metadata = key === "task" ? { sessionId: childID } : key === "websearch" ? { provider: "exa" } : {}
+      const metadata = key === "subagent" ? { 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 })),
@@ -121,12 +127,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 = [
-      { filePath: "src/a.ts", offset: 0, limit: 120 },
+      { path: "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]!, "pending", inputs[index]!))
+    const context = ids.map((id, index) => toolPart(id, tools[index]!, "streaming", inputs[index]!))
     const timeline = await setupTimeline(page, {
       messages: [
         userMessage(),

packages/app/e2e/performance/timeline/session-timeline-benchmark.fixture.ts

@@ -4,6 +4,7 @@ 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"
@@ -26,28 +27,29 @@ const userMessage = {
 
 const editPart: ToolSeed = {
   id: editPartID,
-  sessionID,
-  messageID: assistantMessageID,
   type: "tool",
-  callID: "call_edit_regression",
-  tool: "edit",
+  name: "edit",
   state: {
     status: "completed",
-    input: { filePath: "src/regression.ts" },
-    output: "Edited src/regression.ts",
-    title: "src/regression.ts",
-    metadata: {
-      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",
+    input: {
+      path: "src/regression.ts",
+      oldString: "export const value = 'before'",
+      newString: "export const value = 'after'",
+    },
+    content: [{ type: "text", text: "Edited src/regression.ts" }],
+    metadata: {
+      files: [
+        currentFile(
+          "src/regression.ts",
+          "export const value = 'before'\n",
+          "export const value = 'after'\n",
+          1,
+          1,
+        ),
+      ],
     },
-    time: { start: 1700000001000, end: 1700000002000 },
   },
+  time: { created: 1700000001000, ran: 1700000001000, completed: 1700000002000 },
 }
 
 const assistantMessage = {
@@ -204,20 +206,20 @@ function performanceTurn(index: number) {
       ? [
           {
             id: `prt_0000_${suffix}_edit`,
-            sessionID,
-            messageID: assistantID,
             type: "tool",
-            callID: `call_0000_${suffix}_edit`,
-            tool: "edit",
+            name: "edit",
             state: {
               status: "completed",
-              input: { filePath: `src/history-${index}.ts` },
-              output: `Edited src/history-${index}.ts`,
-              title: `src/history-${index}.ts`,
+              input: { path: `src/history-${index}.ts`, oldString: before, newString: after },
+              content: [{ type: "text", text: `Edited src/history-${index}.ts` }],
               metadata: {
-                filediff: { file: `src/history-${index}.ts`, additions: 48, deletions: 48, before, after },
+                files: [currentFile(`src/history-${index}.ts`, before, after, 48, 48)],
               },
-              time: { start: 1690000001200 + index * 2_000, end: 1690000001400 + index * 2_000 },
+            },
+            time: {
+              created: 1690000001200 + index * 2_000,
+              ran: 1690000001200 + index * 2_000,
+              completed: 1690000001400 + index * 2_000,
             },
           },
         ]
@@ -226,20 +228,18 @@ function performanceTurn(index: number) {
       ? [
           {
             id: `prt_0000_${suffix}_write`,
-            sessionID,
-            messageID: assistantID,
             type: "tool",
-            callID: `call_0000_${suffix}_write`,
-            tool: "write",
+            name: "write",
             state: {
               status: "completed",
-              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 },
+              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,
             },
           },
         ]
@@ -248,31 +248,24 @@ function performanceTurn(index: number) {
       ? [
           {
             id: `prt_0000_${suffix}_patch`,
-            sessionID,
-            messageID: assistantID,
             type: "tool",
-            callID: `call_0000_${suffix}_patch`,
-            tool: "apply_patch",
+            name: "patch",
             state: {
               status: "completed",
               input: { patchText: realisticPatch(index) },
-              output: "Success. Updated src/components/SessionCard.tsx",
-              title: "src/components/SessionCard.tsx",
+              content: [{ type: "text", text: "Success. Updated src/components/SessionCard.tsx" }],
               metadata: {
                 files: [
                   {
-                    filePath: "src/components/SessionCard.tsx",
-                    relativePath: "src/components/SessionCard.tsx",
-                    type: "update",
-                    additions: 8,
-                    deletions: 3,
-                    patch: realisticPatch(index),
-                    before,
-                    after,
+                    ...currentFile("src/components/SessionCard.tsx", before, after, 8, 3),
                   },
                 ],
               },
-              time: { start: 1690000001500 + index * 2_000, end: 1690000001700 + index * 2_000 },
+            },
+            time: {
+              created: 1690000001500 + index * 2_000,
+              ran: 1690000001500 + index * 2_000,
+              completed: 1690000001700 + index * 2_000,
             },
           },
         ]
@@ -309,20 +302,16 @@ function performanceTurn(index: number) {
 }
 
 type ToolSeed = {
-  id?: string
-  sessionID?: string
-  messageID?: string
+  id: string
   type: "tool"
-  callID: string
-  tool: string
+  name: string
   state: {
-    status: string
+    status: "completed"
     input: Record<string, unknown>
-    output: string
-    title?: string
+    content: [{ type: "text"; text: 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 }
@@ -335,13 +324,13 @@ type ContentSeed =
 function toolContent(part: ToolSeed): SessionMessageAssistant["content"][number] {
   return {
     type: "tool",
-    id: part.callID,
-    name: part.tool,
-    time: { created: part.state.time.start, ran: part.state.time.start, completed: part.state.time.end },
+    id: part.id,
+    name: part.name,
+    time: part.time,
     state: {
       status: "completed",
       input: part.state.input as Record<string, JsonValue>,
-      content: [{ type: "text", text: part.state.output }],
+      content: part.state.content,
       metadata: part.state.metadata as Record<string, JsonValue>,
     },
   }
@@ -422,6 +411,16 @@ 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

packages/app/e2e/performance/timeline/session-timeline-profile.ts

@@ -1,4 +1,6 @@
 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)
@@ -12,6 +14,13 @@ 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

packages/app/e2e/performance/timeline/session-timeline-stress.fixture.ts

@@ -1,3 +1,5 @@
+import { createTwoFilesPatch } from "diff"
+
 const words = [
   "alpha",
   "bravo",
@@ -28,22 +30,21 @@ 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" | "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 }
-  }
-}
+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 }
+    }
 
 function lorem(seed: number, length: number) {
   let out = ""
@@ -102,17 +103,16 @@ 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.callID ?? part.id,
-    name: part.tool!,
-    time: { created: state.time.start, ran: state.time.start, completed: state.time.end },
+    id: part.id,
+    name: part.name,
+    time: part.time,
     state: {
       status: "completed",
-      input: state.input as Record<string, JsonValue>,
-      content: [{ type: "text", text: state.output }],
-      metadata: state.metadata as Record<string, JsonValue>,
+      input: part.state.input as Record<string, JsonValue>,
+      content: part.state.content,
+      metadata: part.state.metadata as Record<string, JsonValue>,
     },
   }
 }
@@ -149,43 +149,46 @@ function toolPart(
 ): MessagePart {
   const metadata =
     metadataOverride ??
-    (tool === "apply_patch"
-      ? { files: [patchFile(index, "update"), patchFile(index + 1, index % 2 === 0 ? "add" : "delete")] }
+    (tool === "patch"
+      ? {
+          files: [
+            patchFile(index, "modified"),
+            patchFile(index + 1, index % 2 === 0 ? "added" : "deleted"),
+          ],
+        }
       : tool === "edit" || tool === "write"
-        ? {
-            filediff: fileDiff(String(input.filePath ?? `src/generated/file-${index}.ts`), index),
-            diff: patch(index, outputLength),
-            preview: patch(index + 1, 420),
-          }
+        ? { files: [fileDiff(String(input.path ?? `src/generated/file-${index}.ts`), index)] }
         : tool === "question"
           ? { answers: [["Proceed"], ["Keep sample output"]] }
           : {})
   return {
-    id: id(`prt_tool_${tool}_${partIndex}`, index),
+    id: id(`call_${tool}_${partIndex}`, index),
     type: "tool",
-    callID: id("call", index * 10 + partIndex),
-    tool,
+    name: tool,
     state: {
       status: "completed",
       input,
-      output: lorem(index * 23 + partIndex, outputLength),
-      title: tool === "bash" ? "Verify generated output" : input.filePath || input.path || input.pattern || "completed",
+      content: [{ type: "text", text: lorem(index * 23 + partIndex, outputLength) }],
       metadata,
-      time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
+    },
+    time: {
+      created: 1700000000000 + index * 10_000,
+      ran: 1700000000000 + index * 10_000,
+      completed: 1700000000000 + index * 10_000 + 400,
     },
   }
 }
 
-function patchFile(seed: number, type: "add" | "update" | "delete") {
+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)
   return {
-    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),
+    file,
+    status,
+    additions: status === "deleted" ? 0 : (seed % 7) + 1,
+    deletions: status === "added" ? 0 : seed % 4,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
   }
 }
 
@@ -200,17 +203,13 @@ 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,
-    before,
-    after,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, 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 },
@@ -225,22 +224,24 @@ function turn(index: number): SessionMessageInfo[] {
     ...(index % 5 === 0 ? [reasoningPart(index, 0, 420)] : []),
     ...(index % 3 === 0
       ? [
-          toolPart(index, 0, "read", { filePath: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
+          toolPart(index, 0, "read", { path: `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", { filePath: `src/generated/file-${index}.ts` }, 700)] : []),
+    ...(index % 4 === 0
+      ? [toolPart(index, 3, "edit", { path: `src/generated/file-${index}.ts`, oldString: "before", newString: "after" }, 700)]
+      : []),
     ...(index % 6 === 0
-      ? [toolPart(index, 7, "write", { filePath: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
+      ? [toolPart(index, 7, "write", { path: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
       : []),
     ...(index % 8 === 0
-      ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
+      ? [toolPart(index, 8, "patch", { patchText: `Update generated patch ${index}` }, 620)]
       : []),
     ...(index % 7 === 0
-      ? [toolPart(index, 4, "bash", { command: "bun typecheck", description: "Verify generated output" }, 620)]
+      ? [toolPart(index, 4, "shell", { 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)] : []),
@@ -256,7 +257,15 @@ function turn(index: number): SessionMessageInfo[] {
         ]
       : []),
     ...(index % 17 === 0
-      ? [toolPart(index, 12, "task", { description: "Inspect generated fixture", subagent_type: "explore" }, 160)]
+      ? [
+          toolPart(
+            index,
+            12,
+            "subagent",
+            { description: "Inspect generated fixture", agent: "explore", prompt: "Inspect the fixture." },
+            160,
+          ),
+        ]
       : []),
   ]
   return [user, assistantMessage(targetID, index, user.id, parts)]
@@ -272,10 +281,10 @@ const sourceMessages = Array.from({ length: 12 }, (_, index) => [
           toolPart(
             index + 1000,
             1,
-            "task",
-            { description: "Inspect child navigation", subagent_type: "explore" },
+            "subagent",
+            { description: "Inspect child navigation", agent: "explore", prompt: "Inspect child navigation." },
             160,
-            { sessionId: childID },
+            { sessionID: childID },
           ),
         ]
       : []),

packages/app/e2e/performance/unit/desktop-startup.test.ts

@@ -0,0 +1,88 @@
+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 },
+  }
+}

packages/app/e2e/regression/prompt-input-v2-command-draft.spec.ts

@@ -36,6 +36,9 @@ test("preserves the draft when a populated command menu triggers a built-in", as
   await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
   const composer = page.locator('[data-component="prompt-input-v2"]')
   const input = composer.locator('[data-component="prompt-input"]')
+  await expect.poll(() => input.evaluate((element) => getComputedStyle(element, "::before").content)).toBe(
+    `"${String.fromCodePoint(0x200b)}"`,
+  )
   await expectAppVisible(composer)
 
   await input.fill("keep me")

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

@@ -19,7 +19,7 @@ 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.getByText(sessionB.title).first()).toBeVisible()
+  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
   await page.keyboard.press("Control+,")
 
   const dialog = page.locator(".settings-v2-dialog")
@@ -61,7 +61,7 @@ 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.getByText(sessionA.title).first()).toBeVisible()
+  await expect(page.getByRole("heading", { name: sessionA.title, exact: true })).toBeVisible()
   await page.keyboard.press("Control+,")
   const autoAccept = page.locator(".settings-v2-dialog").locator('[data-action="settings-auto-accept-permissions"]')
   await autoAccept.locator('[data-slot="switch-control"]').click()
@@ -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.getByText(sessionB.title).first()).toBeVisible()
+  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).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: "bash",
+      action: "shell",
       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: "bash",
+      action: "shell",
       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",
-          worktree: directory,
+          canonical: 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 })
+      return json(route, { id: remote ? sessionB.projectID : "project-server-a", directory, canonical: 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: {} })
@@ -237,7 +237,7 @@ function session(id: string, directory: string, title: string) {
     id,
     slug: id,
     projectID: `project-${id}`,
-    directory,
+    location: { directory },
     title,
     version: "dev",
     time: { created: 1, updated: 1 },

packages/app/e2e/regression/session-request-docks.spec.ts

@@ -85,7 +85,7 @@ test("shows a pending permission dock", async ({ page }) => {
       {
         id: "permission-request",
         sessionID,
-        permission: "bash",
+        permission: "shell",
         patterns: ["git status", "git diff"],
         metadata: {},
         always: [],

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

@@ -2,6 +2,7 @@ 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"
@@ -40,18 +41,28 @@ const editPart = {
   tool: "edit",
   state: {
     status: "completed",
-    input: { filePath: "src/regression.ts" },
+    input: {
+      path: "src/regression.ts",
+      oldString: "export const value = 'before'",
+      newString: "export const value = 'after'",
+    },
     output: "Edited src/regression.ts",
     title: "src/regression.ts",
     metadata: {
-      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",
+      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",
+        },
+      ],
     },
     time: { start: 1700000001000, end: 1700000002000 },
   },
@@ -149,13 +160,15 @@ test.describe("regression: session timeline local row state", () => {
         ...editPart.state,
         metadata: {
           ...editPart.state.metadata,
-          filediff: {
-            file: "src/regression.ts",
-            additions: 1,
-            deletions: 1,
-            before: lines,
-            after,
-          },
+          files: [
+            {
+              file: "src/regression.ts",
+              patch: createTwoFilesPatch("a/src/regression.ts", "b/src/regression.ts", lines, after),
+              additions: 5,
+              deletions: 5,
+              status: "modified",
+            },
+          ],
         },
       },
     }

packages/app/e2e/regression/session-timeline-context-resize.spec.ts

@@ -78,7 +78,7 @@ test.describe("regression: session timeline context group resize", () => {
             id("msg_assistant", 10),
             ["read", "glob", "grep", "list"][index]!,
             [
-              { filePath: "src/recent-a.ts" },
+              { path: "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",
-            { filePath: "src/recent-a.ts", offset: 0, limit: 120 },
+            { path: "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.filePath || input.path || input.pattern || "completed",
+      title: input.path || input.pattern || "completed",
       metadata: {},
       time: { start: 1700000000000, end: 1700000000100 },
     },

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

@@ -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: { filePath: "src/a.ts", offset: 0, limit: 120 },
+    read: { path: "src/a.ts", offset: 0, limit: 120 },
     glob: { path: ".", pattern: "**/*.ts" },
   }
   const timeline = await setupTimeline(page, {

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

@@ -7,7 +7,7 @@ test("renders completed write content", async ({ page }) => {
     messages: [
       userMessage(),
       assistantMessage([
-        toolPart(id, "write", "completed", { filePath: "src/write.ts", content: "export const written = true\n" }),
+        toolPart(id, "write", "completed", { path: "src/write.ts", content: "export const written = true\n" }),
       ]),
     ],
     settings: { editToolPartsExpanded: true },
@@ -24,20 +24,19 @@ test("renders a completed single-file patch", async ({ page }) => {
       assistantMessage([
         toolPart(
           id,
-          "apply_patch",
+          "patch",
           "completed",
-          { files: ["src/a.ts"] },
+          { patchText: "Update src/a.ts" },
           {
             metadata: {
               files: [
                 {
-                  filePath: "src/a.ts",
-                  relativePath: "src/a.ts",
-                  type: "update",
+                  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",
                   additions: 1,
                   deletions: 1,
-                  before: "export const value = 1\n",
-                  after: "export const value = 2\n",
                 },
               ],
             },

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

@@ -1,18 +1,19 @@
 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", "update"), patchFile("src/b.ts", "add"), patchFile("src/old.ts", "delete")]
+  const files = [patchFile("src/a.ts", "modified"), patchFile("src/b.ts", "added"), patchFile("src/old.ts", "deleted")]
   await setupTimeline(page, {
     messages: [
       userMessage(),
       assistantMessage([
         toolPart(
           patchID,
-          "apply_patch",
+          "patch",
           "completed",
-          { files: files.map((file) => file.filePath) },
+          { patchText: "Update three files" },
           { metadata: { files } },
         ),
       ]),
@@ -31,15 +32,15 @@ test("preserves nested patch file state through outer collapse and reopen", asyn
   await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "true")
 })
 
-function patchFile(filePath: string, type: "add" | "update" | "delete") {
+function patchFile(file: string, status: "added" | "modified" | "deleted") {
+  const before = status === "added" ? "" : source(false)
+  const after = status === "deleted" ? "" : source(true)
   return {
-    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),
+    file,
+    status,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    additions: status === "deleted" ? 0 : 4,
+    deletions: status === "added" ? 0 : 3,
   }
 }
 

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

@@ -11,7 +11,7 @@ for (const profile of [
       messages: [
         userMessage(),
         assistantMessage([
-          toolPart(ids[0]!, "read", "completed", { filePath: "src/a.ts" }),
+          toolPart(ids[0]!, "read", "completed", { path: "src/a.ts" }),
           toolPart(ids[1]!, "glob", "completed", { path: ".", pattern: "**/*.ts" }),
         ]),
       ],

packages/app/e2e/regression/session-timeline-projection.spec.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", { filePath: "src/a.ts" }),
+      toolPart("prt_01_read", "read", "completed", { path: "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,16 +24,20 @@ test.describe("session timeline projection", () => {
         { query: "timeline stability" },
         { output: "https://example.com/result" },
       ),
-      toolPart("prt_task", "task", "completed", { description: "Inspect timeline", subagent_type: "explore" }),
+      toolPart("prt_task", "subagent", "completed", {
+        description: "Inspect timeline",
+        agent: "explore",
+        prompt: "Inspect the timeline implementation.",
+      }),
       toolPart(
         "prt_bash",
-        "bash",
+        "shell",
         "completed",
         { command: "printf stable" },
         { output: "stable", title: "printf stable" },
       ),
       editPart("prt_edit"),
-      toolPart("prt_write", "write", "completed", { filePath: "src/new.ts", content: "export const stable = true\n" }),
+      toolPart("prt_write", "write", "completed", { path: "src/new.ts", content: "export const stable = true\n" }),
       patchPart("prt_patch"),
       toolPart("prt_todo", "todowrite", "completed", { todos: [{ content: "Hidden", status: "pending" }] }),
       toolPart(
@@ -175,16 +179,10 @@ function editPart(id: string) {
     id,
     "edit",
     "completed",
-    { filePath: "src/a.ts" },
+    { path: "src/a.ts", oldString: "export const value = 1", newString: "export const value = 2" },
     {
       metadata: {
-        filediff: {
-          file: "src/a.ts",
-          additions: 1,
-          deletions: 1,
-          before: "export const value = 1\n",
-          after: "export const value = 2\n",
-        },
+        files: [patchFile("src/a.ts", "modified")],
       },
     },
   )
@@ -193,31 +191,33 @@ function editPart(id: string) {
 function patchPart(id: string) {
   return toolPart(
     id,
-    "apply_patch",
+    "patch",
     "completed",
-    { files: ["src/a.ts", "src/b.ts"] },
+    { patchText: "Update the projected files" },
     {
       metadata: {
         files: [
-          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" },
+          patchFile("src/a.ts", "modified"),
+          patchFile("src/b.ts", "added"),
+          patchFile("src/old.ts", "deleted"),
         ],
       },
     },
   )
 }
 
-function patchFile(filePath: string, type: "add" | "update" | "delete" | "move") {
+function patchFile(file: string, status: "added" | "modified" | "deleted") {
   return {
-    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",
+    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,
   }
 }
 

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

@@ -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", { filePath: "src/a.ts" }),
+    toolPart("prt_boundary_01_read", "read", "completed", { path: "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" }),

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

@@ -67,19 +67,18 @@ 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 = {
-    filePath: "src/outline.ts",
-    relativePath: "src/outline.ts",
-    type: "update",
+    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",
     additions: 1,
     deletions: 1,
-    before: "const outline = false\n",
-    after: "const outline = true\n",
   }
   const timeline = await setupTimeline(page, {
     messages: [
       userMessage(),
       assistantMessage([
-        toolPart(patchID, "apply_patch", "completed", { files: [file.filePath] }, { metadata: { files: [file] } }),
+        toolPart(patchID, "patch", "completed", { patchText: "Update src/outline.ts" }, { metadata: { files: [file] } }),
       ]),
     ],
     settings: { editToolPartsExpanded: true },

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

@@ -8,7 +8,7 @@ import {
 } from "../performance/timeline-stability/fixture"
 
 test("renders every tool error outcome without leaking hidden tools", async ({ page }) => {
-  const ordinary = ["bash", "edit", "write", "apply_patch", "webfetch", "websearch", "task", "skill", "mcp_probe"]
+  const ordinary = ["shell", "edit", "write", "patch", "webfetch", "websearch", "subagent", "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, "bash", "pending", { command: "exit 1" }),
-          toolPart(questionID, "question", "pending", questionInput()),
+          toolPart(shellID, "shell", "streaming", { command: "exit 1" }),
+          toolPart(questionID, "question", "streaming", 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, "bash", "running", { command: "exit 1" })), 120)
+  await timeline.send(partUpdated(toolPart(shellID, "shell", "running", { command: "exit 1" })), 120)
   await timeline.send(partUpdated(toolPart(questionID, "question", "running", questionInput())), 180)
   await expect(page.locator(`[data-timeline-part-id="${questionID}"]`)).toHaveCount(0)
   await timeline.send(
-    partUpdated(toolPart(shellID, "bash", "error", { command: "exit 1" }, { error: "Command exited 1" })),
+    partUpdated(toolPart(shellID, "shell", "error", { command: "exit 1" }, { error: "Command exited 1" })),
     180,
   )
   await timeline.send(
@@ -147,12 +147,13 @@ function questionInput() {
 }
 
 function errorInput(tool: string) {
-  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 === "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 === "webfetch") return { url: "https://example.com" }
   if (tool === "websearch") return { query: "failure" }
-  if (tool === "task") return { description: "Fail task", subagent_type: "explore" }
+  if (tool === "subagent")
+    return { description: "Fail subagent", agent: "explore", prompt: "Inspect the failure." }
   if (tool === "skill") return { name: "failure" }
   return { target: "failure" }
 }

packages/app/e2e/regression/subagent-child-navigation.spec.ts

@@ -167,14 +167,14 @@ function parentMessages(): SessionMessageInfo[] {
       content: [
         {
           type: "tool",
-          id: "call_task_0001",
-          name: "task",
+          id: "call_subagent_0001",
+          name: "subagent",
           time: { created: 1700000001000, ran: 1700000001000, completed: 1700000002000 },
           state: {
             status: "completed",
-            input: { description: taskDescription, subagent_type: "explore" },
+            input: { description: taskDescription, agent: "explore", prompt: "Inspect the delegated work." },
             content: [{ type: "text", text: "Subagent finished" }],
-            metadata: { sessionId: childID },
+            metadata: { sessionID: childID },
           },
         },
       ],

packages/app/e2e/smoke/session-timeline.fixture.ts

@@ -1,3 +1,5 @@
+import { createTwoFilesPatch } from "diff"
+
 const words = [
   "alpha",
   "bravo",
@@ -28,22 +30,21 @@ 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" | "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 }
-  }
-}
+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 }
+    }
 
 function lorem(seed: number, length: number) {
   let out = ""
@@ -102,17 +103,16 @@ 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.callID ?? part.id,
-    name: part.tool!,
-    time: { created: state.time.start, ran: state.time.start, completed: state.time.end },
+    id: part.id,
+    name: part.name,
+    time: part.time,
     state: {
       status: "completed",
-      input: state.input as Record<string, JsonValue>,
-      content: [{ type: "text", text: state.output }],
-      metadata: state.metadata as Record<string, JsonValue>,
+      input: part.state.input as Record<string, JsonValue>,
+      content: part.state.content,
+      metadata: part.state.metadata as Record<string, JsonValue>,
     },
   }
 }
@@ -138,60 +138,61 @@ function toolPart(
   outputLength = 160,
 ): MessagePart {
   const metadata =
-    tool === "apply_patch"
-      ? { files: [patchFile(index, "update"), patchFile(index + 1, index % 2 === 0 ? "add" : "delete")] }
+    tool === "patch"
+      ? {
+          files: [
+            patchFile(index, "modified"),
+            patchFile(index + 1, index % 2 === 0 ? "added" : "deleted"),
+          ],
+        }
       : tool === "edit" || tool === "write"
-        ? {
-            filediff: fileDiff(String(input.filePath ?? `src/generated/file-${index}.ts`), index),
-            diff: patch(index, outputLength),
-            preview: patch(index + 1, 420),
-          }
+        ? { files: [fileDiff(String(input.path ?? `src/generated/file-${index}.ts`), index)] }
         : tool === "question"
           ? { answers: [["Proceed"], ["Keep sample output"]] }
           : {}
   return {
-    id: id(`prt_tool_${tool}_${partIndex}`, index),
+    id: id(`call_${tool}_${partIndex}`, index),
     type: "tool",
-    callID: id("call", index * 100 + partIndex),
-    tool,
+    name: tool,
     state: {
       status: "completed",
       input,
-      output: lorem(index * 23 + partIndex, outputLength),
-      title: tool === "bash" ? input.command : input.filePath || input.path || input.pattern || "completed",
+      content: [{ type: "text", text: lorem(index * 23 + partIndex, outputLength) }],
       metadata,
-      time: { start: 1700000000000 + index * 10_000, end: 1700000000000 + index * 10_000 + 400 },
+    },
+    time: {
+      created: 1700000000000 + index * 10_000,
+      ran: 1700000000000 + index * 10_000,
+      completed: 1700000000000 + index * 10_000 + 400,
     },
   }
 }
 
-function patchFile(seed: number, type: "add" | "update" | "delete") {
+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)
   return {
-    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),
+    file,
+    status,
+    additions: status === "deleted" ? 0 : (seed % 7) + 1,
+    deletions: status === "added" ? 0 : seed % 4,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
   }
 }
 
 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,
-    before: code(seed, 32),
-    after: code(seed + 1, 38),
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, 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) {
   return Array.from({ length: lines }, (_, index) => `export const value${index} = "${lorem(seed + index, 32)}"`).join(
     "\n",
@@ -205,21 +206,23 @@ function turn(index: number): SessionMessageInfo[] {
     ...(index % 5 === 0 ? [reasoningPart(index, 0, 420)] : []),
     ...(index % 3 === 0
       ? [
-          toolPart(index, 0, "read", { filePath: `src/generated/file-${index}.ts`, offset: 0, limit: 80 }, 220),
+          toolPart(index, 0, "read", { path: `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", { filePath: `src/generated/file-${index}.ts` }, 700)] : []),
+    ...(index % 4 === 0
+      ? [toolPart(index, 3, "edit", { path: `src/generated/file-${index}.ts`, oldString: "before", newString: "after" }, 700)]
+      : []),
     ...(index % 6 === 0
-      ? [toolPart(index, 7, "write", { filePath: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
+      ? [toolPart(index, 7, "write", { path: `src/generated/write-${index}.ts`, content: code(index, 28) }, 560)]
       : []),
     ...(index % 8 === 0
-      ? [toolPart(index, 8, "apply_patch", { files: [`src/generated/patch-${index}.ts`] }, 620)]
+      ? [toolPart(index, 8, "patch", { patchText: `Update generated patch ${index}` }, 620)]
       : []),
-    ...(index % 7 === 0 ? [toolPart(index, 4, "bash", { command: "bun typecheck" }, 620)] : []),
+    ...(index % 7 === 0 ? [toolPart(index, 4, "shell", { 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
@@ -234,7 +237,15 @@ function turn(index: number): SessionMessageInfo[] {
         ]
       : []),
     ...(index % 17 === 0
-      ? [toolPart(index, 12, "task", { description: "Inspect generated fixture", subagent_type: "explore" }, 160)]
+      ? [
+          toolPart(
+            index,
+            12,
+            "subagent",
+            { description: "Inspect generated fixture", agent: "explore", prompt: "Inspect the fixture." },
+            160,
+          ),
+        ]
       : []),
   ]
   return [user, assistantMessage(targetID, index, user.id, parts)]
@@ -311,7 +322,7 @@ export const fixture = {
     targetPartIDs: targetMessages.flatMap(currentPartIDs),
     expandedShellPartID: targetMessages
       .flatMap((message) => (message.type === "assistant" ? message.content : []))
-      .flatMap((part) => (part.type === "tool" && part.name === "bash" ? [part.id] : []))[0],
+      .flatMap((part) => (part.type === "tool" && part.name === "shell" ? [part.id] : []))[0],
   },
 }
 

packages/app/e2e/smoke/session-timeline.spec.ts

@@ -518,7 +518,7 @@ async function expectCanScrollToStart(
   let current = await timelineState(page)
   let unchangedAtTop = 0
 
-  for (let attempt = 0; attempt < 600; attempt++) {
+  for (let attempt = 0; attempt < 800; attempt++) {
     collectSeen(current, seenParts, seenMessages)
     samples.push(sampleTraversal(current, seenParts.size, seenMessages.size))
     expectNoSmokeErrors(errors, current.errorToasts, current.forbiddenText)

packages/app/package.json

@@ -5,6 +5,7 @@
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
+    "./desktop": "./src/desktop.ts",
     "./desktop-menu": "./src/desktop-menu.ts",
     "./i18n/desktop-native": "./src/i18n/desktop-native.ts",
     "./updater": "./src/updater.ts",
@@ -28,14 +29,15 @@
     "test:e2e:ui": "playwright test --ui",
     "test:e2e:report": "playwright show-report e2e/playwright-report",
     "test:stability": "bun test ./e2e/performance/unit/visual-stability.test.ts && playwright test --config e2e/performance/timeline-stability/playwright.config.ts",
-    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts"
+    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts",
+    "test:bench:devex": "bun test ./e2e/performance/unit/desktop-startup.test.ts && playwright test --config e2e/performance/devex/playwright.config.ts"
   },
   "license": "MIT",
   "devDependencies": {
     "@happy-dom/global-registrator": "20.0.11",
     "@playwright/test": "catalog:",
     "@sentry/vite-plugin": "catalog:",
-    "@tailwindcss/vite": "catalog:",
+    "@tailwindcss/vite": "4.3.3",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "catalog:",
     "@types/luxon": "catalog:",
@@ -44,9 +46,9 @@
     "happy-dom": "20.11.1",
     "tw-animate-css": "1.4.0",
     "typescript": "catalog:",
-    "vite": "catalog:",
+    "vite": "8.2.1",
     "vite-plugin-icons-spritesheet": "3.0.1",
-    "vite-plugin-solid": "catalog:"
+    "vite-plugin-solid": "2.11.14"
   },
   "dependencies": {
     "@corvu/drawer": "catalog:",
@@ -85,6 +87,6 @@
     "solid-js": "catalog:",
     "solid-list": "catalog:",
     "solid-presence": "0.2.0",
-    "tailwindcss": "catalog:"
+    "tailwindcss": "4.3.3"
   }
 }

packages/app/src/app.tsx

@@ -1,14 +1,10 @@
 import "@/index.css"
-import * as Sentry from "@sentry/solid"
-import { I18nProvider } from "@opencode-ai/ui/context"
-import type { UiI18n } from "@opencode-ai/ui/context/i18n"
 import { DialogProvider } from "@opencode-ai/ui/context/dialog"
 import { FileComponentProvider } from "@opencode-ai/ui/context/file"
-import { File } from "@opencode-ai/session-ui/file"
 import { Font } from "@opencode-ai/ui/font"
 import { ThemeProvider } from "@opencode-ai/ui/theme/context"
 import { MetaProvider } from "@solidjs/meta"
-import { type BaseRouterProps, Navigate, Route, Router, useParams, useSearchParams } from "@solidjs/router"
+import { type BaseRouterProps, Route, Router, useParams } from "@solidjs/router"
 import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import {
   type Component,
@@ -22,30 +18,37 @@ import {
 } from "solid-js"
 import { Dynamic } from "solid-js/web"
 import { CommandProvider, useCommand, type CommandOption } from "@/context/command"
-import { CommentsProvider } from "@/context/comments"
-import { FileProvider } from "@/context/file"
 import { GlobalProvider, useGlobal } from "@/context/global"
 import { HighlightsProvider } from "@/context/highlights"
-import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
+import { LanguageProvider, UiI18nBridge, type Locale, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
-import { ModelsProvider } from "@/context/models"
 import { usePlatform } from "@/context/platform"
-import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServersProvider } from "@/context/servers"
 import { SettingsProvider } from "@/context/settings"
-import { TabsProvider, useTabs, type DraftTab } from "@/context/tabs"
-import { LocationProvider } from "@/context/location"
+import { TabsProvider } from "@/context/tabs"
 import { WslServersProvider } from "@/wsl/context"
-import { SessionUIProvider } from "@/pages/directory-layout"
 import Layout from "@/pages/layout"
 import { ErrorPage } from "./pages/error"
 import { requireServerKey } from "./utils/session-route"
 
-import { TargetSessionRouteContent } from "@/pages/session"
 import { Home } from "@/pages/home"
 import { ServerProvider } from "./context/server"
 
-const NewSession = lazy(() => import("@/pages/new-session"))
+const File = lazy(() => import("@opencode-ai/session-ui/file").then((module) => ({ default: module.File })))
+const loadDraftRoute = () => Promise.all([import("@/pages/draft-route"), File.preload()]).then(([module]) => module)
+const loadSessionRoute = () => Promise.all([import("@/pages/session"), File.preload()]).then(([module]) => module)
+const DraftRoute = lazy(() => loadDraftRoute().then((module) => ({ default: module.DraftRoute })))
+const TargetSessionRouteContent = lazy(() =>
+  loadSessionRoute().then((module) => ({ default: module.TargetSessionRouteContent })),
+)
+
+export function preloadRoute(url: string) {
+  const pathname = url.split(/[?#]/, 1)[0]
+  if (pathname === "/new-session") return DraftRoute.preload().then(() => undefined)
+  if (/^\/server\/[^/]+\/session\/[^/]+$/.test(pathname))
+    return TargetSessionRouteContent.preload().then(() => undefined)
+  return Promise.resolve()
+}
 
 function TargetServerRoute(props: ParentProps) {
   const params = useParams<{ serverKey: string }>()
@@ -62,62 +65,6 @@ function TargetServerRoute(props: ParentProps) {
   )
 }
 
-function DraftRoute() {
-  const [search] = useSearchParams<{ draftId?: string }>()
-  const tabs = useTabs()
-  return (
-    <Show
-      when={tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)}
-      keyed
-      fallback={tabs.ready() && <Navigate href="/" />}
-    >
-      {(draft) => <ResolvedDraftRoute draft={draft} />}
-    </Show>
-  )
-}
-
-function ResolvedDraftRoute(props: { draft: DraftTab }) {
-  const global = useGlobal()
-  const conn = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === props.draft.server))
-
-  return (
-    <Show when={`${props.draft.server}\0${props.draft.directory}`} keyed>
-      <Show when={conn()} keyed>
-        {(conn) => (
-          <ServerProvider conn={conn}>
-            <ModelsProvider directory={props.draft.directory}>
-              <LocationProvider directory={props.draft.directory}>
-                <SessionUIProvider directory={props.draft.directory} server={props.draft.server}>
-                  <DraftProviders>
-                    <NewSession draftId={props.draft.draftID} />
-                  </DraftProviders>
-                </SessionUIProvider>
-              </LocationProvider>
-            </ModelsProvider>
-          </ServerProvider>
-        )}
-      </Show>
-    </Show>
-  )
-}
-
-function UiI18nBridge(props: ParentProps) {
-  const language = useLanguage()
-  return (
-    <I18nProvider
-      value={{
-        locale: language.intl,
-        layoutLocale: language.layoutLocale,
-        t: language.t as UiI18n["t"],
-        plural: language.plural,
-        pluralForm: language.pluralForm,
-      }}
-    >
-      {props.children}
-    </I18nProvider>
-  )
-}
-
 declare global {
   interface Window {
     __OPENCODE__?: {
@@ -186,22 +133,11 @@ function AppLayout(props: ParentProps) {
   )
 }
 
-// The draft page only renders the prompt composer, so it drops TerminalProvider.
-// FileProvider and CommentsProvider stay because PromptInput uses file search and comment context.
-function DraftProviders(props: ParentProps) {
-  return (
-    <FileProvider>
-      <PromptProvider>
-        <CommentsProvider>{props.children}</CommentsProvider>
-      </PromptProvider>
-    </FileProvider>
-  )
-}
-
 export function AppBaseProviders(
   props: ParentProps<{
     locale?: Locale
     onNativeTranslations?: Parameters<typeof LanguageProvider>[0]["onNativeTranslations"]
+    onThemeApplied?: () => void
   }>,
 ) {
   return (
@@ -210,13 +146,14 @@ export function AppBaseProviders(
       <ThemeProvider
         onThemeApplied={(_, mode, scheme) => {
           void window.api?.setTitlebar?.({ mode, scheme })
+          props.onThemeApplied?.()
         }}
       >
         <LanguageProvider locale={props.locale} onNativeTranslations={props.onNativeTranslations}>
           <UiI18nBridge>
             <ErrorBoundary
               fallback={(error) => {
-                Sentry.captureException(error)
+                void import("@sentry/solid").then(({ captureException }) => captureException(error))
                 return <ErrorPage error={error} />
               }}
             >

packages/app/src/components/prompt-input.stories.tsx

@@ -1,125 +0,0 @@
-// @ts-nocheck
-import { createStore } from "solid-js/store"
-import { createPromptState } from "@/context/prompt"
-import { createPromptInputHistory, PromptInput } from "./prompt-input"
-
-function createPromptInputStoryRuntime() {
-  const state = createPromptState()
-  return {
-    state,
-    history: createPromptInputHistory(),
-    submission: {
-      abort() {},
-      handleSubmit(event: Event) {
-        event.preventDefault()
-        state.reset()
-      },
-    },
-  }
-}
-
-function PromptInputExample() {
-  const input = createPromptInputStoryRuntime()
-  const [controls, setControls] = createStore({
-    agent: "build",
-    variant: undefined as string | undefined,
-    comments: 0,
-    tabs: [] as string[],
-    activeTab: undefined as string | undefined,
-    reviewOpen: false,
-  })
-  const storyModel = {
-    id: "claude-3-7-sonnet",
-    name: "Claude 3.7 Sonnet",
-    provider: { id: "anthropic", name: "Anthropic" },
-  }
-  const model = {
-    current: () => storyModel,
-    list: () => [storyModel],
-    visible: () => true,
-    set: () => {},
-    variant: {
-      list: () => ["fast", "thinking"],
-      current: () => controls.variant,
-      set: (variant?: string) => setControls("variant", variant),
-    },
-  }
-  const inputControls = {
-    agents: {
-      available: [{ name: "review", hidden: false, mode: "subagent" }],
-      options: ["build", "review", "plan"],
-      get current() {
-        return controls.agent
-      },
-      loading: false,
-      visible: true,
-      select: (agent?: string) => setControls("agent", agent ?? "build"),
-    },
-    model: {
-      selection: model,
-      paid: true,
-      loading: false,
-    },
-    session: {
-      id: "story-session",
-      tabs: {
-        active: () => controls.activeTab,
-        all: () => controls.tabs,
-        open: (tab: string) => setControls("tabs", (tabs) => (tabs.includes(tab) ? tabs : [...tabs, tab])),
-        setActive: (tab: string) => setControls("activeTab", tab),
-      },
-      reviewPanel: {
-        opened: () => controls.reviewOpen,
-        open: () => setControls("reviewOpen", true),
-      },
-    },
-  }
-  const addReviewComment = () => {
-    const comment = controls.comments + 1
-    setControls("comments", comment)
-    input.state.context.add({
-      type: "file",
-      path: "src/components/prompt-input.tsx",
-      selection: {
-        startLine: 84 + comment,
-        startChar: 0,
-        endLine: 84 + comment,
-        endChar: 0,
-      },
-      comment: `Review comment ${comment}`,
-      commentID: `review-comment-${comment}`,
-      commentOrigin: "review",
-      preview: "export const PromptInput = ...",
-    })
-  }
-
-  return (
-    <div class="flex flex-col gap-3">
-      <PromptInput controls={inputControls} {...input} />
-      <div>
-        <button
-          type="button"
-          class="rounded-md border border-border-weak-base bg-background-base px-2.5 py-1.5 text-12-medium text-text-base hover:bg-background-stronger"
-          onClick={addReviewComment}
-        >
-          Add review comment
-        </button>
-      </div>
-    </div>
-  )
-}
-
-export default {
-  title: "App/PromptInput",
-  id: "app-prompt-input",
-  component: PromptInput,
-}
-
-export const Basic = {
-  render: () => (
-    <div class="pt-10">
-      <h1 class="mb-4">Prompt Input</h1>
-      <PromptInputExample />
-    </div>
-  ),
-}

packages/app/src/components/prompt-input/submit.test.ts

@@ -235,6 +235,9 @@ beforeAll(async () => {
       session: {
         remember: () => undefined,
         setStatus: () => undefined,
+        // Delegates straight to the API client; optimistic admission and
+        // rollback are covered by the data-layer tests in packages/tui.
+        prompt: (input: unknown) => rootClient.api.session.prompt(input as never),
       },
       location: {
         info: () => ({ project: { id: "project", directory: "/repo/main" } }),
@@ -414,7 +417,9 @@ describe("prompt submit worktree selection", () => {
         model: { providerID: "provider", modelID: "model", variant: "high" },
       },
     })
-    expect((promptInputs[0] as { id?: string }).id).toStartWith("msg_")
+    // ID minting is delegated to the data layer, which mints a client ID when
+    // none is supplied (covered by the data-layer tests in packages/tui).
+    expect((promptInputs[0] as { id?: string }).id).toBeUndefined()
   })
 
   test("restores the prompt when sending fails", async () => {

packages/app/src/components/prompt-input/submit.ts

@@ -11,7 +11,7 @@ import { usePermission } from "@/context/permission"
 import { type ContextItem, type ImageAttachmentPart, type Prompt, type usePrompt } from "@/context/prompt"
 import { useWorkspaceLocation } from "@/context/location"
 import { useServerSDK, type ServerSDK } from "@/context/server-sdk"
-import { Identifier } from "@/utils/id"
+import { SessionMessage } from "@opencode-ai/schema/session-message"
 import { getDirectory } from "@opencode-ai/util/path"
 import { buildPromptRequest } from "./build-prompt-request"
 import { setCursorPosition } from "./editor-dom"
@@ -40,7 +40,6 @@ type FollowupSendInput = {
   data: Data
   session: Accessor<{ agent?: string; model?: { id: string; providerID: string; variant?: string } } | undefined>
   draft: FollowupDraft
-  messageID?: string
   optimisticBusy?: boolean
 }
 
@@ -69,10 +68,9 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
   ) {
     setBusy()
     try {
-      const messageID = Identifier.ascending("message")
       await input.api.command({
         sessionID: input.draft.sessionID,
-        id: messageID,
+        id: SessionMessage.ID.create(),
         command: cmd,
         arguments: tail.join(" "),
         agent: input.draft.agent,
@@ -95,7 +93,6 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
     }
   }
 
-  const messageID = input.messageID ?? Identifier.ascending("message")
   const encodedImages = await Promise.all(
     images.map(async (attachment) => ({
       ...attachment,
@@ -132,9 +129,10 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
       })
     }
 
-    await input.api.prompt({
+    // The data layer admits optimistically under a client-minted ID: the
+    // prompt renders immediately and rolls back if the server rejects it.
+    await input.data.session.prompt({
       sessionID: input.draft.sessionID,
-      id: messageID,
       text: request.text,
       files: request.files.map((file) => ({ uri: file.uri, name: file.name, mention: file.mention })),
       agents: request.agents,
@@ -446,12 +444,11 @@ export function createPromptSubmit(input: PromptSubmitInput) {
           ?.find((command) => command.name === commandName)
         if (customCommand) {
           clearInput()
-          const messageID = Identifier.ascending("message")
           submissionData.session.setStatus(session.id, "running")
           void submissionServerSDK.api.session
             .command({
               sessionID: session.id,
-              id: messageID,
+              id: SessionMessage.ID.create(),
               command: commandName,
               arguments: args.join(" "),
               agent,
@@ -476,7 +473,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       }
 
       const commentItems = context.filter((item) => item.type === "file" && !!item.comment?.trim())
-      const messageID = Identifier.ascending("message")
 
       for (const item of commentItems) submission.target().context.remove(item.key)
       clearInput()
@@ -486,7 +482,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
         data: submissionData,
         session: () => session,
         draft,
-        messageID,
         optimisticBusy: sessionDirectory === projectDirectory,
       }).catch((err) => {
         if (sessionDirectory === projectDirectory) {

packages/app/src/components/session/session-header-actions.tsx

@@ -0,0 +1,55 @@
+import { Show, type JSX } from "solid-js"
+import { Icon } from "@opencode-ai/ui/icon"
+import { IconButton } from "@opencode-ai/ui/icon-button"
+import { Keybind } from "@opencode-ai/ui/keybind"
+import { Tooltip } from "@opencode-ai/ui/tooltip"
+
+export type SessionHeaderV2ActionsState = {
+  status?: { label: string; content: () => JSX.Element }
+  reviewLabel: string
+  reviewKeybind: string[]
+  reviewVisible: boolean
+  reviewOpened: boolean
+  onReviewToggle: () => void
+}
+
+export function SessionHeaderV2Actions(props: { state: SessionHeaderV2ActionsState }) {
+  return (
+    <div class="flex items-center gap-2">
+      <Show when={props.state.status}>
+        {(status) => (
+          <Tooltip appearance="standard" placement="bottom" value={status().label}>
+            {status().content()}
+          </Tooltip>
+        )}
+      </Show>
+      <Show when={props.state.reviewVisible}>
+        <Tooltip
+          class="shrink-0"
+          placement="bottom"
+          value={
+            <>
+              {props.state.reviewLabel}
+              <Show when={props.state.reviewKeybind.length > 0}>
+                <Keybind keys={props.state.reviewKeybind} variant="neutral" />
+              </Show>
+            </>
+          }
+        >
+          <IconButton
+            type="button"
+            variant="ghost-muted"
+            size="large"
+            class="!w-9 shrink-0"
+            state={props.state.reviewOpened ? "pressed" : undefined}
+            onClick={props.state.onReviewToggle}
+            aria-label={props.state.reviewLabel}
+            aria-expanded={props.state.reviewOpened}
+            aria-controls="review-panel"
+            icon={<Icon name="sidebar-right" />}
+          />
+        </Tooltip>
+      </Show>
+    </div>
+  )
+}

packages/app/src/components/session/session-header.tsx

@@ -6,12 +6,9 @@ import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { StatusPopoverV2 } from "../status-popover"
-import { IconButton } from "@opencode-ai/ui/icon-button"
-import { Icon } from "@opencode-ai/ui/icon"
-import { Keybind } from "@opencode-ai/ui/keybind"
-import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { reviewTooltipKeybind } from "../command-tooltip-keybind"
 import { useTitlebarRightMount } from "../titlebar"
+import { SessionHeaderV2Actions, type SessionHeaderV2ActionsState } from "./session-header-actions"
 
 export function SessionHeader() {
   const command = useCommand()
@@ -23,8 +20,7 @@ export function SessionHeader() {
   const isDesktop = createMediaQuery("(min-width: 768px)")
 
   const v2ActionsState = createMemo<SessionHeaderV2ActionsState>(() => ({
-    statusVisible: status(),
-    statusLabel: language.t("status.popover.trigger"),
+    status: status() ? { label: language.t("status.popover.trigger"), content: () => <StatusPopoverV2 /> } : undefined,
     reviewLabel: language.t("command.review.toggle"),
     reviewKeybind: reviewTooltipKeybind(command),
     reviewVisible: isDesktop(),
@@ -44,52 +40,3 @@ export function SessionHeader() {
     </Show>
   )
 }
-
-type SessionHeaderV2ActionsState = {
-  statusVisible: boolean
-  statusLabel: string
-  reviewLabel: string
-  reviewKeybind: string[]
-  reviewVisible: boolean
-  reviewOpened: boolean
-  onReviewToggle: () => void
-}
-
-function SessionHeaderV2Actions(props: { state: SessionHeaderV2ActionsState }) {
-  return (
-    <div class="flex items-center gap-2">
-      <Show when={props.state.statusVisible}>
-        <Tooltip appearance="standard" placement="bottom" value={props.state.statusLabel}>
-          <StatusPopoverV2 />
-        </Tooltip>
-      </Show>
-      <Show when={props.state.reviewVisible}>
-        <Tooltip
-          class="shrink-0"
-          placement="bottom"
-          value={
-            <>
-              {props.state.reviewLabel}
-              <Show when={props.state.reviewKeybind.length > 0}>
-                <Keybind keys={props.state.reviewKeybind} variant="neutral" />
-              </Show>
-            </>
-          }
-        >
-          <IconButton
-            type="button"
-            variant="ghost-muted"
-            size="large"
-            class="!w-9 shrink-0"
-            state={props.state.reviewOpened ? "pressed" : undefined}
-            onClick={props.state.onReviewToggle}
-            aria-label={props.state.reviewLabel}
-            aria-expanded={props.state.reviewOpened}
-            aria-controls="review-panel"
-            icon={<Icon name="sidebar-right" />}
-          />
-        </Tooltip>
-      </Show>
-    </div>
-  )
-}

packages/app/src/components/titlebar.tsx

@@ -241,7 +241,11 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                     sessionId: activeSession.id,
                   }
                   const model = tabs.stateValue<PromptSession>(sessionTab, "prompt")?.model.current()
-                  tabs.newDraft({ server: sessionTab.server, directory: activeSession.location.directory }, "", model)
+                  void tabs.newDraft(
+                    { server: sessionTab.server, directory: activeSession.location.directory },
+                    "",
+                    model,
+                  )
                   return
                 }
                 case "draft": {
@@ -249,7 +253,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                   if (activeTab?.type !== "draft") return
 
                   const model = tabs.stateValue<PromptSession>(activeTab, "prompt")?.model.current()
-                  tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "", model)
+                  void tabs.newDraft({ server: activeTab.server, directory: activeTab.directory }, "", model)
                   return
                 }
                 case "home": {
@@ -263,7 +267,7 @@ export function Titlebar(props: { update?: TitlebarUpdate; debugTools?: { visibl
                     projects?.list().find((item) => item.worktree === projects.last()) ??
                     projects?.list()[0]
                   if (conn && project) {
-                    tabs.newDraft({ server: ServerConnection.key(conn), directory: project.worktree }, "")
+                    void tabs.newDraft({ server: ServerConnection.key(conn), directory: project.worktree }, "")
                     return
                   }
                 }
@@ -467,11 +471,14 @@ function ChannelIndicator(props: { debugTools?: { visible: boolean; toggle: () =
     )
   }
 
+  const label = channel && ["local", "beta", "dev"].includes(channel) ? channel.toUpperCase() : undefined
   return (
-    <Show when={["local", "beta", "dev"].includes(channel)}>
-      <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
-        {channel.toUpperCase()}
-      </div>
+    <Show when={label}>
+      {(value) => (
+        <div class="bg-icon-interactive-base text-[#FFF] font-medium px-2 rounded-sm uppercase font-mono">
+          {value()}
+        </div>
+      )}
     </Show>
   )
 }

packages/app/src/context/language.tsx

@@ -1,8 +1,10 @@
 import * as i18n from "@solid-primitives/i18n"
-import { createEffect, createMemo, createResource } from "solid-js"
+import { createEffect, createMemo, createResource, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import {
+  I18nProvider,
+  type UiI18n,
   pluralCategory,
   type UiI18nPluralLookupKey,
   type UiI18nPluralKey,
@@ -260,3 +262,20 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
     }
   },
 })
+
+export function UiI18nBridge(props: { children?: JSX.Element }) {
+  const language = useLanguage()
+  return (
+    <I18nProvider
+      value={{
+        locale: language.intl,
+        layoutLocale: language.layoutLocale,
+        t: language.t as UiI18n["t"],
+        plural: language.plural,
+        pluralForm: language.pluralForm,
+      }}
+    >
+      {props.children}
+    </I18nProvider>
+  )
+}

packages/app/src/desktop.ts

@@ -0,0 +1,9 @@
+export { AppBaseProviders, AppInterface, preloadRoute } from "./app"
+export { ACCEPTED_FILE_EXTENSIONS } from "./constants/file-picker"
+export { useCommand } from "./context/command"
+export { loadLocaleDict, normalizeLocale, type Locale, useLanguage } from "./context/language"
+export { type Platform, PlatformProvider } from "./context/platform"
+export { ServerConnection, useServers } from "./context/servers"
+export { useTabs } from "./context/tabs"
+export { createDraftStore } from "./utils/draft-store"
+export { useWslServers } from "./wsl/context"

packages/app/src/hooks/provider-order.ts

@@ -0,0 +1,10 @@
+export const popularProviders = [
+  "opencode",
+  "opencode-go",
+  "anthropic",
+  "github-copilot",
+  "openai",
+  "google",
+  "openrouter",
+  "vercel",
+]

packages/app/src/hooks/use-providers.ts

@@ -5,17 +5,9 @@ import { Iterable, pipe } from "effect"
 import { createEffect, createMemo, type Accessor } from "solid-js"
 import { emptyProviderCatalog } from "./provider-catalog"
 import { useIntegrations } from "./use-integrations"
+import { popularProviders } from "./provider-order"
 
-export const popularProviders = [
-  "opencode",
-  "opencode-go",
-  "anthropic",
-  "github-copilot",
-  "openai",
-  "google",
-  "openrouter",
-  "vercel",
-]
+export { popularProviders } from "./provider-order"
 const popularProviderSet = new Set(popularProviders)
 
 export function useProviders(directory: Accessor<string | undefined>) {

packages/app/src/index.ts

@@ -1,4 +1,4 @@
-export { AppBaseProviders, AppInterface } from "./app"
+export { AppBaseProviders, AppInterface, preloadRoute } from "./app"
 export { useLayout } from "./context/layout"
 export { useServerSDK } from "./context/server-sdk"
 export { useServers as useServers } from "./context/servers"

packages/app/src/pages/draft-route.tsx

@@ -0,0 +1,64 @@
+import { Navigate, useSearchParams } from "@solidjs/router"
+import { createMemo, Show, type ParentProps } from "solid-js"
+import { CommentsProvider } from "@/context/comments"
+import { FileProvider } from "@/context/file"
+import { useGlobal } from "@/context/global"
+import { LocationProvider } from "@/context/location"
+import { ModelsProvider } from "@/context/models"
+import { PromptProvider } from "@/context/prompt"
+import { ServerProvider } from "@/context/server"
+import { ServerConnection } from "@/context/servers"
+import { useTabs, type DraftTab } from "@/context/tabs"
+import { SessionUIProvider } from "@/pages/directory-layout"
+import NewSession from "@/pages/new-session"
+
+export function DraftRoute() {
+  const [search] = useSearchParams<{ draftId?: string }>()
+  const tabs = useTabs()
+  return (
+    <Show
+      when={tabs.store.find((tab): tab is DraftTab => tab.type === "draft" && tab.draftID === search.draftId)}
+      keyed
+      fallback={tabs.ready() && <Navigate href="/" />}
+    >
+      {(draft) => <ResolvedDraftRoute draft={draft} />}
+    </Show>
+  )
+}
+
+function ResolvedDraftRoute(props: { draft: DraftTab }) {
+  const global = useGlobal()
+  const conn = createMemo(() => global.servers.list().find((item) => ServerConnection.key(item) === props.draft.server))
+
+  return (
+    <Show when={`${props.draft.server}\0${props.draft.directory}`} keyed>
+      <Show when={conn()} keyed>
+        {(conn) => (
+          <ServerProvider conn={conn}>
+            <ModelsProvider directory={props.draft.directory}>
+              <LocationProvider directory={props.draft.directory}>
+                <SessionUIProvider directory={props.draft.directory} server={props.draft.server}>
+                  <DraftProviders>
+                    <NewSession draftId={props.draft.draftID} />
+                  </DraftProviders>
+                </SessionUIProvider>
+              </LocationProvider>
+            </ModelsProvider>
+          </ServerProvider>
+        )}
+      </Show>
+    </Show>
+  )
+}
+
+// The draft page only renders the prompt composer, so it drops TerminalProvider.
+// FileProvider and CommentsProvider stay because PromptInput uses file search and comment context.
+function DraftProviders(props: ParentProps) {
+  return (
+    <FileProvider>
+      <PromptProvider>
+        <CommentsProvider>{props.children}</CommentsProvider>
+      </PromptProvider>
+    </FileProvider>
+  )
+}

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

@@ -1,10 +1,8 @@
 import { useDirectoryPicker } from "@/components/directory-picker"
 import { useServerActionsController } from "@/components/server/server-management-controller"
 import { useSettingsCommand } from "@/components/settings-dialog"
-import { DialogServerV2 } from "@/components/settings-v2/dialog-server-v2"
 import { type LocalProject } from "@/context/layout"
 import { useLanguage } from "@/context/language"
-import { useNotification } from "@/context/notification"
 import { usePlatform } from "@/context/platform"
 import { ServerConnection } from "@/context/servers"
 import { closeHomeProject, errorMessage, homeProjectDirectories } from "@/pages/layout/helpers"
@@ -63,7 +61,11 @@ export function createHomeProjectsController(home: HomeController) {
         serverManagement.defaults.set(conn ? ServerConnection.key(conn) : null),
       canRemove: (conn: ServerConnection.Any) => serverManagement.connection.canRemove(ServerConnection.key(conn)),
       remove: (conn: ServerConnection.Any) => serverManagement.connection.remove(ServerConnection.key(conn)),
-      edit: (conn: ServerConnection.Http) => dialog.show(() => <DialogServerV2 mode="edit" server={conn} />),
+      edit: (conn: ServerConnection.Http) => {
+        void import("@/components/settings-v2/dialog-server-v2").then(({ DialogServerV2 }) => {
+          void dialog.show(() => <DialogServerV2 mode="edit" server={conn} />)
+        })
+      },
       focus: home.selection.focusServer,
     },
     project: {

packages/app/src/pages/layout.tsx

@@ -1,13 +1,14 @@
-import { Show, Suspense, type ParentProps } from "solid-js"
+import { lazy, Show, Suspense, type ParentProps } from "solid-js"
 import { createStore } from "solid-js/store"
-import { DebugBar } from "@/components/debug-bar"
 import { Titlebar, type TitlebarUpdate } from "@/components/titlebar"
 import { usePlatform } from "@/context/platform"
 import { ToastRegion } from "@/utils/toast"
 
+const DebugBar = lazy(() => import("@/components/debug-bar").then((module) => ({ default: module.DebugBar })))
+
 export default function Layout(props: ParentProps) {
   const platform = usePlatform()
-  const [state, setState] = createStore({ debugTools: true })
+  const [state, setState] = createStore({ debugTools: false })
 
   const update: TitlebarUpdate = {
     get version() {
@@ -41,7 +42,9 @@ export default function Layout(props: ParentProps) {
         <Suspense>{props.children}</Suspense>
       </main>
       <Show when={import.meta.env.DEV && state.debugTools}>
-        <DebugBar inline />
+        <Suspense>
+          <DebugBar inline />
+        </Suspense>
       </Show>
       <ToastRegion />
     </div>

packages/app/src/pages/new-session/new-session-workspace-controller.test.ts

@@ -39,14 +39,20 @@ describe("new session workspace selection", () => {
     expect(normalizeNewSessionWorktree("main", "C:\\Repo\\", "c:/repo")).toBe("main")
   })
 
-  test("falls back to the local branch for main, create, and unknown worktrees", () => {
+  test("resolves the branch from the active location", () => {
     const branch = (worktree: string) => (worktree === "/project/feature" ? "feature" : undefined)
-    expect(resolveNewSessionBranch({ worktree: "main", local: "dev", worktreeBranch: branch })).toBe("dev")
-    expect(resolveNewSessionBranch({ worktree: "create", local: "dev", worktreeBranch: branch })).toBe("dev")
-    expect(resolveNewSessionBranch({ worktree: "/project/feature", local: "dev", worktreeBranch: branch })).toBe(
+    expect(resolveNewSessionBranch({ worktree: "main", directory: "/project/feature", worktreeBranch: branch })).toBe(
       "feature",
     )
-    expect(resolveNewSessionBranch({ worktree: "/missing", local: "dev", worktreeBranch: branch })).toBe("dev")
+    expect(
+      resolveNewSessionBranch({ worktree: "create", directory: "/project/feature", worktreeBranch: branch }),
+    ).toBe("feature")
+    expect(
+      resolveNewSessionBranch({ worktree: "/project/feature", directory: "/project", worktreeBranch: branch }),
+    ).toBe("feature")
+    expect(resolveNewSessionBranch({ worktree: "/missing", directory: "/project/feature", worktreeBranch: branch })).toBe(
+      undefined,
+    )
   })
 
   test("uses location VCS state when the project inventory is stale", () => {