refactor(core): make watcher subscription effectful

feat(session): define explicit fork boundaries
fix(session): hide pending admission sequence
2026-07-29 14:16:16 +00:00 · 2026-07-29 09:50:24 -04:00 · 2026-07-29 09:50:24 -04:00 · 2026-07-29 09:50:24 -04:00 · 2026-07-29 18:23:00 +05:30 · 2026-07-29 18:22:41 +05:30
114 changed files with 1610 additions and 1186 deletions
@@ -46,7 +46,7 @@ const response = yield * LLMClient.generate(request)

 `LLM.request(...)` builds an `LLMRequest`. `LLMClient.generate(...)` reads the executable route carried by `request.model.route`, builds the provider-native body, asks the route's transport for a real `HttpClientRequest.HttpClientRequest`, sends it through `RequestExecutor.Service`, parses the provider stream into common `LLMEvent`s, and finally returns an `LLMResponse`.

-Use `LLMClient.stream(request)` when callers want incremental `LLMEvent`s. Use `LLMClient.generate(request)` when callers want those same events collected into an `LLMResponse`. Use `LLMClient.prepare<Body>(request)` to compile a request through the route pipeline without sending it — the optional `Body` type argument narrows `.body` to the route's native shape (e.g. `prepare<OpenAIChatBody>(...)` returns a `PreparedRequestOf<OpenAIChatBody>`). The runtime body is identical; the generic is a type-level assertion.
+Use `LLMClient.stream(request)` when callers want incremental `LLMEvent`s. Use `LLMClient.generate(request)` when callers want those same events collected into an `LLMResponse`.

 Filter or narrow `LLMEvent` streams with `LLMEvent.is.*` (camelCase guards, e.g. `events.filter(LLMEvent.is.toolCall)`). The kebab-case `LLMEvent.guards["tool-call"]` form also works but prefer `is.*` in new code.

@@ -138,13 +138,13 @@ packages/ai/src/
    ids.ts                  branded IDs, literal types, ProviderMetadata
    options.ts              Generation/Provider/Http options, Limits, Model, cache policy
    messages.ts             content parts, Message, ToolDefinition, LLMRequest
-    events.ts               Usage, individual events, LLMEvent, PreparedRequest, LLMResponse
+    events.ts               Usage, individual events, LLMEvent, LLMResponse
    errors.ts               error reasons, LLMError, ToolFailure
    index.ts                barrel
  llm.ts                    request constructors and convenience helpers
  route/
    index.ts                @opencode-ai/ai/route advanced barrel
-    client.ts               Route.make + LLMClient.prepare/stream/generate
+    client.ts               Route.make + LLMClient.stream/generate
    executor.ts             RequestExecutor service + transport error mapping
    protocol.ts             Protocol type + Protocol.make
    endpoint.ts             Endpoint type + Endpoint.path
@@ -196,7 +196,6 @@ The hosted result is represented as a provider-executed tool call and tool resul
 - **`LLM.generate` / `LLM.stream`** — re-exported from `LLMClient` for one-import use.
 - **`Message.user(...)` / `Message.assistant(...)` / `Message.tool(...)`** — message constructors from the canonical schema model.
 - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
- **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
 - **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
 - **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
@@ -568,7 +568,7 @@ App boundary = explicit durable-config -> typed-provider call
      calling `.model(...)`.
 - [x] Remove request-shaping defaults from `Model`; selected models now carry only
      id, provider, and configured route while defaults live on routes or requests.
- [x] Rework `LLMClient.prepare` / `stream` / `generate` to read
+- [x] Rework `LLMClient.stream` / `generate` to read
      `request.model.route` directly instead of calling `registeredRoute(...)`.
 - [x] Remove `Route.make(...)` global registration from the normal execution
      path; keep route ids only as diagnostics/provider API labels.
@@ -50,18 +50,6 @@ const request = LLM.request({
  },
 })

-// `http` is intentionally not needed for normal calls. This shows the shape for
-// newly released provider fields before they deserve a typed provider option.
-const rawOverlayExample = LLM.request({
-  model,
-  prompt: "Show the final HTTP overlay shape.",
-  http: {
-    body: { metadata: { example: "tutorial" } },
-    headers: { "x-opencode-tutorial": "1" },
-    query: { debug: "1" },
-  },
-})
-
 // 3. `generate` sends the request and collects the event stream into one
 // response object. `response.text` is the collected text output.
 const generateOnce = Effect.gen(function* () {
@@ -222,33 +210,15 @@ const FakeEcho = {
  }),
 }

-// `LLMClient.prepare` is the lower-level inspection hook: it compiles through
-// body conversion, validation, endpoint, auth, and HTTP construction without
-// sending anything over the network.
-const inspectFakeProvider = Effect.gen(function* () {
-  const prepared = yield* LLMClient.prepare(
-    LLM.request({
-      model: FakeEcho.configure().model("tiny-echo"),
-      prompt: "Show me the provider pipeline.",
-    }),
-  )
-
-  console.log("\n== fake provider prepare ==")
-  console.log("route:", prepared.route)
-  console.log("body:", Formatter.formatJson(prepared.body, { space: 2 }))
-})
-
 // Provide the LLM runtime and the HTTP request executor once. Keep one path
-// enabled at a time so the tutorial can demonstrate generate, prepare, stream,
-// or tool-loop behavior without spending tokens on every example.
+// enabled at a time so the tutorial can demonstrate generate, stream, or
+// tool-loop behavior without spending tokens on every example.
 const requestExecutorLayer = RequestExecutor.fetchLayer
 const llmDeps = Layer.mergeAll(requestExecutorLayer, WebSocketExecutor.layer)
 const llmClientLayer = LLMClient.layer.pipe(Layer.provide(llmDeps))

 const program = Effect.gen(function* () {
  // yield* generateOnce
-  // yield* inspectFakeProvider
-  // yield* LLMClient.prepare(rawOverlayExample).pipe(Effect.andThen((prepared) => Effect.sync(() => console.log(prepared.body))))
  // yield* streamText
  // yield* generateStructuredObject
  // yield* generateDynamicObject.pipe(Effect.andThen((response) => Effect.sync(() => console.log(response.object))))
@@ -9,25 +9,28 @@ import {
  LLMRequest,
  LLMResponse,
  Message,
+  Model,
  SystemPart,
  ToolChoice,
  ToolDefinition,
  type ContentPart,
+  type ModelProviderOptions,
 } from "./schema"
 import { make as makeTool, toDefinitions, type ToolSchema } from "./tool"

 /** Input accepted by `LLM.request`, normalized into the canonical `LLMRequest` class. */
-export type RequestInput = Omit<
+export type RequestInput<SelectedModel extends Model = Model> = Omit<
  ConstructorParameters<typeof LLMRequest>[0],
-  "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"
+  "model" | "system" | "messages" | "tools" | "toolChoice" | "generation" | "http" | "providerOptions"
 > & {
+  readonly model: SelectedModel
  readonly system?: string | SystemPart | ReadonlyArray<SystemPart>
  readonly prompt?: string | ContentPart | ReadonlyArray<ContentPart>
  readonly messages?: ReadonlyArray<Message | Message.Input>
  readonly tools?: ReadonlyArray<ToolDefinition.Input>
  readonly toolChoice?: ToolChoice.Input
  readonly generation?: GenerationOptions.Input
-  readonly providerOptions?: ConstructorParameters<typeof LLMRequest>[0]["providerOptions"]
+  readonly providerOptions?: NoInfer<ModelProviderOptions<SelectedModel>>
  readonly http?: HttpOptions.Input
 }

@@ -35,7 +38,7 @@ export const generate = LLMClient.generate

 export const stream = LLMClient.stream

-export const request = (input: RequestInput) => {
+export const request = <const SelectedModel extends Model>(input: RequestInput<SelectedModel>) => {
  const {
    system: requestSystem,
    prompt,
@@ -63,7 +66,7 @@ const GENERATE_OBJECT_TOOL_NAME = "generate_object"

 const GENERATE_OBJECT_TOOL_DESCRIPTION = "Return the structured result by calling this tool."

-type GenerateObjectBase = Omit<RequestInput, "tools" | "toolChoice">
+type GenerateObjectBase<SelectedModel extends Model = Model> = Omit<RequestInput<SelectedModel>, "tools" | "toolChoice">

 export class GenerateObjectResponse<T> {
  constructor(
@@ -80,11 +83,13 @@ export class GenerateObjectResponse<T> {
  }
 }

-export interface GenerateObjectOptions<S extends ToolSchema<any>> extends GenerateObjectBase {
+export interface GenerateObjectOptions<S extends ToolSchema<any>, SelectedModel extends Model = Model>
+  extends GenerateObjectBase<SelectedModel> {
  readonly schema: S
 }

-export interface GenerateObjectDynamicOptions extends GenerateObjectBase {
+export interface GenerateObjectDynamicOptions<SelectedModel extends Model = Model>
+  extends GenerateObjectBase<SelectedModel> {
  /** Raw JSON Schema object describing the expected output shape. */
  readonly jsonSchema: JsonSchema.JsonSchema
 }
@@ -137,11 +142,11 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
 * 2. `jsonSchema: JsonSchema.JsonSchema` — `.object` is `unknown`. Use when
 *    the schema is only available at runtime (MCP, plugin manifests). Caller validates.
 */
-export function generateObject<S extends ToolSchema<any>>(
-  options: GenerateObjectOptions<S>,
+export function generateObject<const SelectedModel extends Model, S extends ToolSchema<any>>(
+  options: GenerateObjectOptions<S, SelectedModel>,
 ): Effect.Effect<GenerateObjectResponse<Schema.Schema.Type<S>>, LLMError>
-export function generateObject(
-  options: GenerateObjectDynamicOptions,
+export function generateObject<const SelectedModel extends Model>(
+  options: GenerateObjectDynamicOptions<SelectedModel>,
 ): Effect.Effect<GenerateObjectResponse<unknown>, LLMError>
 export function generateObject(options: GenerateObjectOptions<ToolSchema<any>> | GenerateObjectDynamicOptions) {
  if ("schema" in options) {
@@ -1,4 +1,4 @@
-import type { Model } from "./schema"
+import type { Model, ProviderOptions } from "./schema"

 export interface Settings extends Readonly<Record<string, unknown>> {
  readonly headers?: Readonly<Record<string, string>>
@@ -9,8 +9,11 @@ export interface Settings extends Readonly<Record<string, unknown>> {
  }
 }

-export interface Definition<ProviderSettings extends Settings = Settings> {
-  readonly model: (modelID: string, settings: ProviderSettings) => Model
+export interface Definition<
+  ProviderSettings extends Settings = Settings,
+  Options extends ProviderOptions = ProviderOptions,
+> {
+  readonly model: (modelID: string, settings: ProviderSettings) => Model<Options>
 }

 export * as ProviderPackage from "./provider-package"
@@ -47,7 +47,7 @@ export const configure = (input: Config) => {
  })
  return {
    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -57,7 +57,10 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+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({
@@ -52,7 +52,10 @@ export const configure = (input: Config = {}) => {
 }

 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+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({
@@ -99,10 +99,14 @@ export const configure = (input: Config) => {
  const modelDefaults = defaults(input)

  const responses = (modelID: string | ModelID) =>
-    configuredResponsesRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID })
+    configuredResponsesRoute
+      .with(withOpenAIOptions(modelID, modelDefaults))
+      .model<OpenAIProviderOptionsInput>({ id: modelID })

  const chat = (modelID: string | ModelID) =>
-    configuredChatRoute.with(withOpenAIOptions(modelID, modelDefaults)).model({ id: modelID })
+    configuredChatRoute
+      .with(withOpenAIOptions(modelID, modelDefaults))
+      .model<OpenAIProviderOptionsInput>({ id: modelID })

  return {
    id,
@@ -133,8 +137,12 @@ const config = (settings: Settings): Config => {
  throw new Error("Azure requires resourceName or baseURL")
 }

-export const responsesModel: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure(config(settings)).responses(modelID)
-export const chatModel: ProviderPackage.Definition<Settings>["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 chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).chat(modelID)
 export const model = responsesModel
@@ -4,6 +4,7 @@ import { Auth } from "../route/auth"
 import { AuthOptions, type AtLeastOne, type ProviderAuthOption } from "../route/auth-options"
 import type { RouteDefaultsInput } from "../route/client"
 import { ProviderID, type ModelID } from "../schema"
+import type { OpenAIProviderOptionsInput } from "./openai-options"

 export const aiGatewayID = ProviderID.make("cloudflare-ai-gateway")
 export const workersAIID = ProviderID.make("cloudflare-workers-ai")
@@ -20,10 +21,11 @@ type GatewayURL = AtLeastOne<{
 }

 export type AIGatewayOptions = GatewayURL &
-  RouteDefaultsInput &
+  Omit<RouteDefaultsInput, "providerOptions"> &
  ProviderAuthOption<"optional"> & {
    /** Cloudflare AI Gateway authentication token. Sent as `cf-aig-authorization`. */
    readonly gatewayApiKey?: CloudflareSecret
+    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 type WorkersAIURL = AtLeastOne<{
@@ -31,7 +33,11 @@ type WorkersAIURL = AtLeastOne<{
  readonly baseURL: string
 }>

-export type WorkersAIOptions = WorkersAIURL & RouteDefaultsInput & ProviderAuthOption<"optional">
+export type WorkersAIOptions = WorkersAIURL &
+  Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly providerOptions?: OpenAIProviderOptionsInput
+  }

 export const aiGatewayBaseURL = (input: GatewayURL) => {
  if (input.baseURL) return input.baseURL
@@ -98,7 +104,7 @@ const configureAIGateway = (options: AIGatewayOptions) => {
  })
  return {
    id: aiGatewayID,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
    configure: configureAIGateway,
  }
 }
@@ -111,7 +117,7 @@ const configureWorkersAI = (options: WorkersAIOptions) => {
  })
  return {
    id: workersAIID,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
    configure: configureWorkersAI,
  }
 }
@@ -50,9 +50,11 @@ export const configure = (options: ModelOptions) => {
  const responsesRoute = configuredResponsesRoute(options)
  const chatRoute = configuredChatRoute(options)
  const responses = (modelID: string | ModelID) =>
-    responsesRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID })
+    responsesRoute
+      .with(withOpenAIOptions(modelID, defaults(options)))
+      .model<OpenAIProviderOptionsInput>({ id: modelID })
  const chat = (modelID: string | ModelID) =>
-    chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model({ id: modelID })
+    chatRoute.with(withOpenAIOptions(modelID, defaults(options))).model<OpenAIProviderOptionsInput>({ id: modelID })
  return {
    id,
    model: (modelID: string | ModelID) =>
@@ -1,8 +1,9 @@
 import type { ProviderPackage } from "../provider-package"
 import { OpenAICompatibleChat } from "../protocols/openai-compatible-chat"
 import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
+import { ProviderID, type ModelID } from "../schema"
 import { GoogleVertexShared } from "./google-vertex-shared"
+import type { OpenAIProviderOptionsInput } from "./openai-options"

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

@@ -11,6 +12,7 @@ export type Config = RouteDefaultsInput &
    readonly baseURL?: string
    readonly location?: string
    readonly project?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export interface Settings extends ProviderPackage.Settings {
@@ -19,7 +21,7 @@ export interface Settings extends ProviderPackage.Settings {
  readonly baseURL?: string
  readonly location?: string
  readonly project?: string
-  readonly providerOptions?: ProviderOptions
+  readonly providerOptions?: OpenAIProviderOptionsInput
 }

 const route = OpenAICompatibleChat.route.with({
@@ -56,7 +58,7 @@ export const configure = (input: Config = {}) => {
  const route = configuredRoute(input)
  return {
    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenAIProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -66,7 +68,7 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+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({
    accessToken: settings.accessToken,
@@ -91,7 +91,7 @@ export const configure = (input: Config = {}) => {
  const route = configuredRoute(input)
  return {
    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<AnthropicMessages.ProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -101,7 +101,10 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+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({
    accessToken: settings.accessToken,
@@ -1,8 +1,9 @@
 import type { ProviderPackage } from "../provider-package"
 import { OpenAICompatibleResponses } from "../protocols/openai-compatible-responses"
 import type { RouteDefaultsInput } from "../route/client"
-import { ProviderID, type ModelID, type ProviderOptions } from "../schema"
+import { ProviderID, type ModelID } from "../schema"
 import { GoogleVertexShared } from "./google-vertex-shared"
+import type { OpenResponsesProviderOptionsInput } from "./open-responses-options"

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

@@ -11,6 +12,7 @@ export type Config = RouteDefaultsInput &
    readonly baseURL?: string
    readonly location?: string
    readonly project?: string
+    readonly providerOptions?: OpenResponsesProviderOptionsInput
  }

 export interface Settings extends ProviderPackage.Settings {
@@ -19,7 +21,7 @@ export interface Settings extends ProviderPackage.Settings {
  readonly baseURL?: string
  readonly location?: string
  readonly project?: string
-  readonly providerOptions?: ProviderOptions
+  readonly providerOptions?: OpenResponsesProviderOptionsInput
 }

 const route = OpenAICompatibleResponses.route.with({
@@ -58,7 +60,7 @@ export const configure = (input: Config = {}) => {
  const route = configuredRoute(input)
  return {
    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenResponsesProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -68,7 +70,10 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+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({
    accessToken: settings.accessToken,
@@ -77,7 +77,8 @@ const configuredRoute = (input: Config, modelID: string | ModelID) => {
 export const configure = (input: Config = {}) => {
  return {
    id,
-    model: (modelID: string | ModelID) => configuredRoute(input, modelID).model({ id: modelID }),
+    model: (modelID: string | ModelID) =>
+      configuredRoute(input, modelID).model<Gemini.ProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -86,7 +87,10 @@ export const provider = {
  id,
  configure,
 }
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["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({
@@ -50,14 +50,14 @@ export const configure = (input: Config = {}) => {
    })
  return {
    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<Gemini.ProviderOptionsInput>({ id: modelID }),
    image,
    configure,
  }
 }

 export const provider = configure()
-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"] = (modelID, settings) =>
  configure({
    apiKey: settings.apiKey,
    baseURL: settings.baseURL,
@@ -36,7 +36,7 @@ export const configure = (input: Config) => {
  })
  return {
    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenResponsesProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -46,7 +46,10 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenResponsesProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) =>
  configure({
    apiKey: settings.apiKey,
    baseURL: settings.baseURL,
@@ -4,13 +4,15 @@ import type { RouteDefaultsInput } from "../route/client"
 import { AuthOptions, type ProviderAuthOption } from "../route/auth-options"
 import type { ProviderPackage } from "../provider-package"
 import { profiles, type OpenAICompatibleProfile } from "./openai-compatible-profile"
+import type { OpenAIProviderOptionsInput } from "./openai-options"

 export const id = ProviderID.make("openai-compatible")

-type GenericModelOptions = RouteDefaultsInput &
+type GenericModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
  ProviderAuthOption<"optional"> & {
    readonly provider?: string
    readonly baseURL: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export interface Settings extends ProviderPackage.Settings {
@@ -19,9 +21,10 @@ export interface Settings extends ProviderPackage.Settings {
  readonly provider?: string
 }

-export type FamilyModelOptions = RouteDefaultsInput &
+export type FamilyModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
  ProviderAuthOption<"optional"> & {
    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export const routes = [OpenAICompatibleChat.route]
@@ -37,7 +40,8 @@ export const configure = (input: GenericModelOptions) => {
  })
  return {
    id: ProviderID.make(provider),
-    model: (modelID: string | ModelID) => route.model({ id: modelID, provider: ProviderID.make(provider) }),
+    model: (modelID: string | ModelID) =>
+      route.model<OpenAIProviderOptionsInput>({ id: modelID, provider: ProviderID.make(provider) }),
    configure,
  }
 }
@@ -63,7 +67,7 @@ export const provider = {
  configure,
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) =>
  configure({
    apiKey: settings.apiKey,
    baseURL: settings.baseURL,
@@ -86,10 +86,15 @@ export const configure = (input: Config = {}) => {
  const chatRoute = configuredRoute(OpenAIChat.route, input)
  const modelDefaults = defaults(input)
  const responses = (id: string | ModelID) =>
-    responsesRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id })
+    responsesRoute
+      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+      .model<OpenAIProviderOptionsInput>({ id })
  const responsesWebSocket = (id: string | ModelID) =>
-    responsesWebSocketRoute.with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true })).model({ id })
-  const chat = (id: string | ModelID) => chatRoute.with(withOpenAIOptions(id, modelDefaults)).model({ id })
+    responsesWebSocketRoute
+      .with(withOpenAIOptions(id, modelDefaults, { textVerbosity: true }))
+      .model<OpenAIProviderOptionsInput>({ id })
+  const chat = (id: string | ModelID) =>
+    chatRoute.with(withOpenAIOptions(id, modelDefaults)).model<OpenAIProviderOptionsInput>({ id })
  const image = (modelID: string | ModelID) =>
    OpenAIImages.model({
      id: modelID,
@@ -132,15 +137,17 @@ const config = (settings: Settings): Config => {
  }
 }

-export const model: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) => {
+export const model: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (modelID, settings) => {
  const configured = configure(config(settings))
  if (settings.transport === undefined || settings.transport === "http") return configured.responses(modelID)
  if (settings.transport === "websocket") return configured.responsesWebSocket(modelID)
  throw new Error(`Unsupported OpenAI Responses transport: ${String(settings.transport)}`)
 }

-export const chatModel: ProviderPackage.Definition<Settings>["model"] = (modelID, settings) =>
-  configure(config(settings)).chat(modelID)
+export const chatModel: ProviderPackage.Definition<Settings, OpenAIProviderOptionsInput>["model"] = (
+  modelID,
+  settings,
+) => configure(config(settings)).chat(modelID)
 export const responses = provider.responses
 export const responsesWebSocket = provider.responsesWebSocket
 export const chat = provider.chat
@@ -107,7 +107,7 @@ export const configure = (input: ModelOptions = {}) => {
  const route = configuredRoute(input)
  return {
    id,
-    model: (modelID: string | ModelID) => route.model({ id: modelID }),
+    model: (modelID: string | ModelID) => route.model<OpenRouterProviderOptionsInput>({ id: modelID }),
    configure,
  }
 }
@@ -5,12 +5,14 @@ import * as OpenAICompatibleProfiles from "./openai-compatible-profile"
 import * as OpenAICompatibleChat from "../protocols/openai-compatible-chat"
 import * as OpenAIResponses from "../protocols/openai-responses"
 import { XAIImages } from "../protocols/xai-images"
+import type { OpenAIProviderOptionsInput } from "./openai-options"

 export const id = ProviderID.make("xai")

-export type ModelOptions = RouteDefaultsInput &
+export type ModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
  ProviderAuthOption<"optional"> & {
    readonly baseURL?: string
+    readonly providerOptions?: OpenAIProviderOptionsInput
  }

 export type { XAIImageOptions } from "../protocols/xai-images"
@@ -42,8 +44,8 @@ const configuredChatRoute = (input: ModelOptions) => {
 export const configure = (input: ModelOptions = {}) => {
  const responsesRoute = configuredResponsesRoute(input)
  const chatRoute = configuredChatRoute(input)
-  const responses = (modelID: string | ModelID) => responsesRoute.model({ id: modelID })
-  const chat = (modelID: string | ModelID) => chatRoute.model({ id: modelID })
+  const responses = (modelID: string | ModelID) => responsesRoute.model<OpenAIProviderOptionsInput>({ id: modelID })
+  const chat = (modelID: string | ModelID) => chatRoute.model<OpenAIProviderOptionsInput>({ id: modelID })
  const image = (modelID: string | ModelID) =>
    XAIImages.model({
      id: modelID,
@@ -10,7 +10,7 @@ import { WebSocketExecutor } from "./transport"
 import type { Protocol } from "./protocol"
 import { applyCachePolicy } from "../cache-policy"
 import * as ProviderShared from "../protocols/shared"
-import type { LLMError, PreparedRequestOf, ProtocolID, ProviderOptions } from "../schema"
+import type { LLMError, ProtocolID, ProviderOptions } from "../schema"
 import {
  GenerationOptions,
  HttpOptions,
@@ -20,7 +20,6 @@ import {
  ModelLimits,
  LLMError as LLMErrorClass,
  LLMEvent,
-  PreparedRequest,
  ProviderID,
  mergeGenerationOptions,
  mergeHttpOptions,
@@ -46,7 +45,7 @@ export interface Route<Body, Prepared = unknown> {
  readonly defaults: RouteDefaults
  readonly body: RouteBody<Body>
  readonly with: (patch: RoutePatch<Body, Prepared>) => Route<Body, Prepared>
-  readonly model: (input: RouteMappedModelInput) => Model
+  readonly model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) => Model<Options>
  readonly prepareTransport: (body: Body, request: LLMRequest) => Effect.Effect<Prepared, LLMError>
  readonly streamPrepared: (
    prepared: Prepared,
@@ -93,12 +92,12 @@ export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {

 type RouteMappedModelInput = RouteModelInput | RouteRoutedModelInput

-const makeRouteModel = (route: AnyRoute, mapped: RouteMappedModelInput) => {
+const makeRouteModel = <Options extends ProviderOptions = ProviderOptions>(route: AnyRoute, mapped: RouteMappedModelInput) => {
  const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined)
  if (!provider) throw new Error(`Route.model(${route.id}) requires a provider`)
  if (!endpointBaseURL(route.endpoint))
    throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`)
-  return Model.make({
+  return Model.make<Options>({
    ...mapped,
    provider,
    route,
@@ -142,17 +141,6 @@ export const httpOptions = (input: HttpOptionsInput | undefined) => {
 }

 export interface Interface {
-  /**
-   * Compile a request through protocol body construction, validation, and HTTP
-   * preparation without sending it. Returns the prepared request including the
-   * provider-native body.
-   *
-   * Pass a `Body` type argument to statically expose the route's body
-   * shape (e.g. `prepare<OpenAIChatBody>(...)`) — the runtime body is
-   * identical, so this is a type-level assertion the caller makes about which
-   * route the request will resolve to.
-   */
-  readonly prepare: <Body = unknown>(request: LLMRequest) => Effect.Effect<PreparedRequestOf<Body>, LLMError>
  readonly stream: StreamMethod
  readonly generate: GenerateMethod
 }
@@ -296,7 +284,8 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
          defaults: mergeRouteDefaults(route.defaults, defaults),
        })
      },
-      model: (input) => makeRouteModel(route, input),
+      model: <Options extends ProviderOptions = ProviderOptions>(input: RouteMappedModelInput) =>
+        makeRouteModel<Options>(route, input),
      prepareTransport: (body, request) =>
        routeInput.transport.prepare({
          body,
@@ -370,9 +359,6 @@ export function make<Body, Prepared, Frame, Event, State>(
  })
 }

-// `compile` is the important boundary: it turns a common `LLMRequest` into a
-// validated provider body plus transport-private prepared data, but does not
-// execute transport.
 const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest) {
  const resolved = applyCachePolicy(resolveRequestOptions(request))
  const route = resolved.model.route
@@ -390,17 +376,17 @@ const compile = Effect.fn("LLM.compile")(function* (request: LLMRequest) {
  }
 })

-const prepareWith = Effect.fn("LLMClient.prepare")(function* (request: LLMRequest) {
+/** @internal Test-only projection of the execution compiler; not exported from package barrels. */
+export const compileRequest = Effect.fn("LLM.compileRequest")(function* (request: LLMRequest) {
  const compiled = yield* compile(request)
-
-  return new PreparedRequest({
+  return {
    id: compiled.request.id ?? "request",
    route: compiled.route.id,
    protocol: compiled.route.protocol,
    model: compiled.request.model,
    body: compiled.body,
    metadata: { transport: compiled.route.transport.id },
-  })
+  }
 })

 const streamRequestWith = (runtime: TransportRuntime) => (request: LLMRequest) =>
@@ -422,9 +408,6 @@ const generateWith = (stream: Interface["stream"]) =>
    )
  })

-export const prepare = <Body = unknown>(request: LLMRequest) =>
-  prepareWith(request) as Effect.Effect<PreparedRequestOf<Body>, LLMError>
-
 export function stream(request: LLMRequest): Stream.Stream<LLMEvent, LLMError> {
  return Stream.unwrap(
    Effect.gen(function* () {
@@ -453,7 +436,7 @@ export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer
      http: yield* RequestExecutor.Service,
      webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
    })
-    return Service.of({ prepare: prepareWith as Interface["prepare"], stream, generate: generateWith(stream) })
+    return Service.of({ stream, generate: generateWith(stream) })
  }),
 )

@@ -462,7 +445,6 @@ export const Route = { make } as const
 export const LLMClient = {
  Service,
  layer,
-  prepare,
  stream,
  generate,
 } as const
@@ -1,6 +1,5 @@
 import { Schema } from "effect"
-import { ContentBlockID, FinishReason, ProtocolID, ProviderMetadata, RouteID, ToolCallID } from "./ids"
-import { ModelSchema } from "./options"
+import { ContentBlockID, FinishReason, ProviderMetadata, ToolCallID } from "./ids"
 import { Message, ToolCallPart, ToolOutput, ToolResultPart, ToolResultValue, type ContentPart } from "./messages"
 import { ProviderFailureClassification } from "./errors"

@@ -314,29 +313,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
 })
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>

-export class PreparedRequest extends Schema.Class<PreparedRequest>("LLM.PreparedRequest")({
-  id: Schema.String,
-  route: RouteID,
-  protocol: ProtocolID,
-  model: ModelSchema,
-  body: Schema.Unknown,
-  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
-}) {}
-
-/**
- * A `PreparedRequest` whose `body` is typed as `Body`. Use with the generic
- * on `LLMClient.prepare<Body>(...)` when the caller knows which route their
- * request will resolve to and wants its native shape statically exposed
- * (debug UIs, request previews, plan rendering).
- *
- * The runtime body is identical — the route still emits `body: unknown` — so
- * this is a type-level assertion the caller makes about what they expect to
- * find. The prepare runtime does not validate the assertion.
- */
-export type PreparedRequestOf<Body> = Omit<PreparedRequest, "body"> & {
-  readonly body: Body
-}
-
 const responseText = (events: ReadonlyArray<LLMEvent>) =>
  events
    .filter(LLMEvent.is.textDelta)
@@ -178,7 +178,8 @@ export namespace ModelCompatibility {
  export const make = (input: Input) => (input instanceof ModelCompatibility ? input : new ModelCompatibility(input))
 }

-export class Model {
+export class Model<Options extends ProviderOptions = ProviderOptions> {
+  declare protected readonly _ProviderOptions: Options
  readonly id: ModelID
  readonly provider: ProviderID
  readonly route: AnyRoute
@@ -193,8 +194,8 @@ export class Model {
    this.compatibility = input.compatibility
  }

-  static make(input: Model.Input) {
-    return new Model({
+  static make<Options extends ProviderOptions = ProviderOptions>(input: Model.Input) {
+    return new Model<Options>({
      id: ModelID.make(input.id),
      provider: ProviderID.make(input.provider),
      route: input.route,
@@ -203,7 +204,7 @@ export class Model {
    })
  }

-  static input(model: Model): Model.ConstructorInput {
+  static input<Options extends ProviderOptions>(model: Model<Options>): Model.ConstructorInput {
    return {
      id: model.id,
      provider: model.provider,
@@ -213,9 +214,9 @@ export class Model {
    }
  }

-  static update(model: Model, patch: Partial<Model.Input>) {
+  static update<Options extends ProviderOptions>(model: Model<Options>, patch: Partial<Model.Input>) {
    if (Object.keys(patch).length === 0) return model
-    return Model.make({
+    return Model.make<Options>({
      ...Model.input(model),
      ...patch,
    })
@@ -241,6 +242,8 @@ export namespace Model {

 export type ModelInput = Model.Input

+export type ModelProviderOptions<SelectedModel> = SelectedModel extends Model<infer Options> ? Options : never
+
 export const ModelSchema = Schema.declare((value): value is Model => value instanceof Model, { expected: "LLM.Model" })

 export class CacheHint extends Schema.Class<CacheHint>("LLM.CacheHint")({
@@ -99,7 +99,6 @@ export const layer = (options: LayerOptions = {}) =>
        )
      }) as LLMClientShape["stream"]
      const client = LLMClient.Service.of({
-        prepare: () => Effect.die("TestLLM does not prepare provider-native requests"),
        stream,
        generate: (request) =>
          stream(request).pipe(
@@ -2,6 +2,7 @@ import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { LLM, LLMRequest, LLMResponse } from "../src"
 import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route"
+import { compileRequest } from "../src/route/client"
 import { Model } from "../src/schema"
 import { testEffect } from "./lib/effect"
 import { dynamicResponse } from "./lib/http"
@@ -139,8 +140,7 @@ describe("llm route", () => {

  it.effect("selects routes by model route value", () =>
    Effect.gen(function* () {
-      const llm = yield* LLMClient.Service
-      const prepared = yield* llm.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, { model: updateModel(request.model, { route: configuredGemini }) }),
      )

@@ -173,7 +173,7 @@ describe("llm route", () => {
        framing: fakeFraming,
      })

-      const prepared = yield* (yield* LLMClient.Service).prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, { model: updateModel(request.model, { route: duplicate }) }),
      )

@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { CacheHint, LLM, Message } from "../src"
-import { Auth, LLMClient } from "../src/route"
+import { Auth } from "../src/route"
+import { compileRequest } from "../src/route/client"
 import { AmazonBedrock } from "../src/providers"
 import * as AnthropicMessages from "../src/protocols/anthropic-messages"
 import * as Gemini from "../src/protocols/gemini"
@@ -31,7 +32,7 @@ const geminiModel = Gemini.route
 describe("applyCachePolicy", () => {
  it.effect("undefined cache resolves to 'auto' (the recommended default)", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: "You are concise.",
@@ -50,7 +51,7 @@ describe("applyCachePolicy", () => {

  it.effect("'auto' marks the last tool, first and last system parts, and final message boundary on Anthropic", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: [
@@ -87,7 +88,7 @@ describe("applyCachePolicy", () => {

  it.effect("'auto' is a no-op on OpenAI (implicit caching protocol)", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: openaiModel,
          system: "Sys",
@@ -106,7 +107,7 @@ describe("applyCachePolicy", () => {

  it.effect("'auto' is a no-op on Gemini (out-of-band caching protocol)", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: geminiModel,
          system: "Sys",
@@ -123,7 +124,7 @@ describe("applyCachePolicy", () => {

  it.effect("'auto' on Bedrock emits cachePoint markers in the right places", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: bedrockModel,
          system: [
@@ -157,7 +158,7 @@ describe("applyCachePolicy", () => {

  it.effect("'none' disables auto placement even when manual hints exist", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: "Sys",
@@ -176,7 +177,7 @@ describe("applyCachePolicy", () => {

  it.effect("granular object form: tools-only marks just tools", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: "Sys",
@@ -195,7 +196,7 @@ describe("applyCachePolicy", () => {

  it.effect("auto policy preserves manual CacheHints on other parts", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: [
@@ -241,7 +242,7 @@ describe("applyCachePolicy", () => {
      expect("cache" in tail ? tail.cache : undefined).toBeUndefined()
      expect(applyCachePolicy(applied)).toBe(applied)

-      const prepared = yield* LLMClient.prepare(request)
+      const prepared = yield* compileRequest(request)

      const body = prepared.body as {
        tools: Array<{ cache_control?: unknown }>
@@ -261,7 +262,7 @@ describe("applyCachePolicy", () => {

  it.effect("ttlSeconds in the policy flows through to wire markers", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          system: "Sys",
@@ -278,7 +279,7 @@ describe("applyCachePolicy", () => {

  it.effect("messages: { tail: 2 } marks the last 2 message boundaries", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2"), Message.assistant("a2")],
@@ -296,7 +297,7 @@ describe("applyCachePolicy", () => {

  it.effect("'latest-assistant' marks the last assistant message", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: anthropicModel,
          messages: [Message.user("u1"), Message.assistant("a1"), Message.user("u2")],
@@ -4,6 +4,7 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, mergeProviderOptions } from "../src"
 import { AnthropicMessages, OpenAIChat } from "../src/protocols"
 import { Auth, LLMClient } from "../src/route"
+import { compileRequest } from "../src/route/client"
 import { it } from "./lib/effect"
 import { dynamicResponse } from "./lib/http"
 import { deltaChunk } from "./lib/openai-chunks"
@@ -44,7 +45,7 @@ describe("request option precedence", () => {
    })
  })

-  it.effect("prepares bodies with route defaults, model defaults, and call options in order", () =>
+  it.effect("compiles bodies with route defaults, model defaults, and call options in order", () =>
    Effect.gen(function* () {
      const route = OpenAIChat.route.with({
        endpoint: { baseURL: "https://api.openai.test/v1/" },
@@ -59,7 +60,7 @@ describe("request option precedence", () => {
          providerOptions: { openai: { reasoningEffort: "medium" } },
        },
      })
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "Say hello.",
@@ -141,7 +142,7 @@ describe("request option precedence", () => {
      const model = OpenAIChat.route
        .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
        .model({ id: "gpt-4o-mini" })
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model,
          prompt: "Say hello.",
@@ -164,10 +165,8 @@ describe("request option precedence", () => {
        limits: { output: 128 },
      })
      const model = route.model({ id: "claude-sonnet-4-5", defaults: { limits: { output: 64 } } })
-      const withoutMaxTokens = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({ model, prompt: "Say hello.", cache: "none" }),
-      )
-      const withMaxTokens = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      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 } }),
      )

@@ -0,0 +1,47 @@
+import { Schema } from "effect"
+import { LLM, type Model, type ModelProviderOptions, type ProviderOptions } from "../src"
+import { OpenAIChat } from "../src/protocols"
+
+interface ExampleOptions {
+  readonly [key: string]: unknown
+  readonly mode?: "fast" | "thorough"
+}
+
+type ExampleProviderOptions = ProviderOptions & {
+  readonly example?: ExampleOptions
+}
+
+const model = OpenAIChat.route
+  .with({ endpoint: { baseURL: "https://example.com/v1" } })
+  .model<ExampleProviderOptions>({ id: "example" })
+
+LLM.request({ model, prompt: "Hello", providerOptions: { example: { mode: "fast" } } })
+LLM.request({ model, prompt: "Hello", providerOptions: { future: { option: true } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Known provider options preserve their value types.
+  providerOptions: { example: { mode: "slow" } },
+})
+
+LLM.generateObject({
+  model,
+  prompt: "Hello",
+  schema: Schema.Struct({ answer: Schema.String }),
+  providerOptions: { example: { mode: "thorough" } },
+})
+
+LLM.generateObject({
+  model,
+  prompt: "Hello",
+  jsonSchema: { type: "object" },
+  // @ts-expect-error Dynamic object generation uses the selected model's provider options.
+  providerOptions: { example: { mode: false } },
+})
+
+declare const generic: Model
+LLM.request({ model: generic, prompt: "Hello", providerOptions: { arbitrary: { option: true } } })
+
+const options: ModelProviderOptions<typeof model> = { example: { mode: "fast" } }
+void options
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { AnthropicCompatible } from "../../src/providers"
+
+const model = AnthropicCompatible.configure({ baseURL: "https://example.com" }).model("claude")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { anthropic: { effort: "high" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Anthropic effort must be a string.
+  providerOptions: { anthropic: { effort: 1 } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { Anthropic } from "../../src/providers"
+
+const model = Anthropic.provider.model("claude-sonnet-4-5")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { anthropic: { thinking: { type: "adaptive" } } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Anthropic thinking modes are a fixed union.
+  providerOptions: { anthropic: { thinking: { type: "automatic" } } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { Azure } from "../../src/providers"
+
+const model = Azure.configure({ resourceName: "example" }).responses("deployment")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { store: false } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Azure OpenAI store must be boolean.
+  providerOptions: { openai: { store: "false" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { CloudflareWorkersAI } from "../../src/providers"
+
+const model = CloudflareWorkersAI.configure({ accountId: "account", apiKey: "test" }).model("model")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { promptCacheKey: "cache" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Cloudflare's OpenAI-compatible prompt cache key must be a string.
+  providerOptions: { openai: { promptCacheKey: 1 } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { GitHubCopilot } from "../../src/providers"
+
+const model = GitHubCopilot.configure({ baseURL: "https://example.com" }).model("gpt-5")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningSummary: "auto" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Copilot reasoning summaries use the OpenAI union.
+  providerOptions: { openai: { reasoningSummary: "full" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { GoogleVertexChat } from "../../src/providers"
+
+const model = GoogleVertexChat.configure({ accessToken: "test", project: "project" }).model("gemini")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { serviceTier: "priority" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Vertex OpenAI-compatible service tiers use the OpenAI union.
+  providerOptions: { openai: { serviceTier: "premium" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { GoogleVertexMessages } from "../../src/providers"
+
+const model = GoogleVertexMessages.configure({ accessToken: "test", project: "project" }).model("claude")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { anthropic: { effort: "medium" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Vertex Anthropic effort must be a string.
+  providerOptions: { anthropic: { effort: false } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { GoogleVertexResponses } from "../../src/providers"
+
+const model = GoogleVertexResponses.configure({ accessToken: "test", project: "project" }).model("gemini")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openresponses: { textVerbosity: "high" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Vertex Responses verbosity uses the Open Responses union.
+  providerOptions: { openresponses: { textVerbosity: "verbose" } },
+})
@@ -0,0 +1,17 @@
+import { LLM } from "../../src"
+import { GoogleVertex } from "../../src/providers"
+
+const model = GoogleVertex.provider.configure({ apiKey: "test" }).model("gemini-2.5-pro")
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  providerOptions: { gemini: { thinkingConfig: { includeThoughts: true } } },
+})
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Vertex Gemini includeThoughts must be boolean.
+  providerOptions: { gemini: { thinkingConfig: { includeThoughts: "yes" } } },
+})
@@ -0,0 +1,17 @@
+import { LLM } from "../../src"
+import { Google } from "../../src/providers"
+
+const model = Google.provider.model("gemini-2.5-pro")
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 1024 } } },
+})
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Gemini thinking budgets must be numeric.
+  providerOptions: { gemini: { thinkingConfig: { thinkingBudget: "large" } } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { OpenAICompatibleResponses } from "../../src/providers"
+
+const model = OpenAICompatibleResponses.configure({ baseURL: "https://example.com" }).model("model")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openresponses: { reasoningSummary: "detailed" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error Open Responses reasoning summaries use a fixed union.
+  providerOptions: { openresponses: { reasoningSummary: "full" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { OpenAICompatible } from "../../src/providers"
+
+const model = OpenAICompatible.deepseek.model("deepseek-chat")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { store: false } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error OpenAI-compatible store must be boolean.
+  providerOptions: { openai: { store: "false" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { OpenAI } from "../../src/providers"
+
+const model = OpenAI.responses("gpt-5")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningEffort: "high" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error OpenAI reasoning effort must be a string.
+  providerOptions: { openai: { reasoningEffort: 1 } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { OpenRouter } from "../../src/providers"
+
+const model = OpenRouter.provider.model("anthropic/claude-sonnet-4.5")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openrouter: { usage: true } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error OpenRouter usage must be boolean or an option record.
+  providerOptions: { openrouter: { usage: "yes" } },
+})
@@ -0,0 +1,13 @@
+import { LLM } from "../../src"
+import { XAI } from "../../src/providers"
+
+const model = XAI.provider.model("grok-4")
+
+LLM.request({ model, prompt: "Hello", providerOptions: { openai: { reasoningEffort: "high" } } })
+
+LLM.request({
+  model,
+  prompt: "Hello",
+  // @ts-expect-error xAI's OpenAI-compatible reasoning effort must be a string.
+  providerOptions: { openai: { reasoningEffort: true } },
+})
@@ -3,6 +3,7 @@ import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { CacheHint, LLM, LLMError, LLMRequest, Message, ToolCallPart, ToolDefinition, Usage } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import * as AnthropicMessages from "../../src/protocols/anthropic-messages"
 import { continuationRequest, nativeAnthropicMessagesContinuation } from "../continuation-scenarios"
 import { it } from "../lib/effect"
@@ -44,7 +45,7 @@ const expectToolResult = (body: AnthropicMessages.AnthropicMessagesBody): Anthro
 describe("Anthropic Messages route", () => {
  it.effect("prepares Anthropic Messages target", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(request)
+      const prepared = yield* compileRequest(request)

      expect(prepared.body).toEqual({
        model: "claude-sonnet-4-5",
@@ -59,7 +60,7 @@ describe("Anthropic Messages route", () => {

  it.effect("lowers adaptive thinking settings with effort", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: {
            anthropic: { thinking: { type: "adaptive", display: "summarized" }, effort: "low" },
@@ -76,17 +77,17 @@ describe("Anthropic Messages route", () => {

  it.effect("normalizes enabled and disabled thinking settings", () =>
    Effect.gen(function* () {
-      const enabled = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const enabled = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { anthropic: { thinking: { type: "enabled", budgetTokens: 1_024 } } },
        }),
      )
-      const legacy = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const legacy = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { anthropic: { thinking: { type: "enabled", budget_tokens: 2_048 } } },
        }),
      )
-      const disabled = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const disabled = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { anthropic: { thinking: { type: "disabled" } } },
        }),
@@ -100,7 +101,7 @@ describe("Anthropic Messages route", () => {

  it.effect("rejects enabled thinking without a budget", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { anthropic: { thinking: { type: "enabled" } } },
        }),
@@ -112,7 +113,7 @@ describe("Anthropic Messages route", () => {

  it.effect("lowers chronological system updates natively for Claude Opus 4.8 with cache hints", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: opus48,
          messages: [
@@ -137,7 +138,7 @@ describe("Anthropic Messages route", () => {

  it.effect("lowers chronological system updates to wrapped user text for unsupported Anthropic models", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -164,7 +165,7 @@ describe("Anthropic Messages route", () => {

  it.effect("rejects non-text chronological system update content before send", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model: opus48,
          messages: [
@@ -181,7 +182,7 @@ describe("Anthropic Messages route", () => {
  it.effect("falls back for unsupported native chronological system update placement", () =>
    Effect.gen(function* () {
      expect(
-        (yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+        (yield* compileRequest(
          LLM.request({
            model: opus48,
            messages: [Message.assistant("Plain."), Message.system("After plain assistant.")],
@@ -196,12 +197,11 @@ describe("Anthropic Messages route", () => {
        },
      ])
      expect(
-        (yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-          LLM.request({ model: opus48, messages: [Message.system("First.")], cache: "none" }),
-        )).body.messages,
+        (yield* compileRequest(LLM.request({ model: opus48, messages: [Message.system("First.")], cache: "none" })))
+          .body.messages,
      ).toEqual([{ role: "user", content: [{ type: "text", text: "<system-update>\nFirst.\n</system-update>" }] }])
      expect(
-        (yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+        (yield* compileRequest(
          LLM.request({
            model: opus48,
            messages: [Message.user("Before."), Message.system("One."), Message.system("Two.")],
@@ -223,7 +223,7 @@ describe("Anthropic Messages route", () => {

  it.effect("rejects a system update between a local tool call and its result", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model: opus48,
          messages: [
@@ -242,7 +242,7 @@ describe("Anthropic Messages route", () => {

  it.effect("prepares tool call and tool result messages", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result",
          model,
@@ -273,7 +273,7 @@ describe("Anthropic Messages route", () => {

  it.effect("keeps tools and sends tool_choice none", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_choice_none",
          model,
@@ -303,7 +303,7 @@ describe("Anthropic Messages route", () => {
  // not JSON-stringified into `tool_result.content`.
  it.effect("lowers media tool-result content as structured blocks", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_image",
          model,
@@ -335,7 +335,7 @@ describe("Anthropic Messages route", () => {

  it.effect("lowers single-image tool-result content as a structured image block", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_image_only",
          model,
@@ -360,7 +360,7 @@ describe("Anthropic Messages route", () => {

  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_unsupported_media",
          model,
@@ -384,7 +384,7 @@ describe("Anthropic Messages route", () => {

  it.effect("prepares the composed native continuation request", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        continuationRequest({
          id: "req_native_continuation_anthropic",
          model,
@@ -428,7 +428,7 @@ describe("Anthropic Messages route", () => {

  it.effect("lowers preserved Anthropic reasoning signature metadata", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -447,7 +447,7 @@ describe("Anthropic Messages route", () => {

  it.effect("round-trips redacted thinking as redacted_thinking blocks", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -628,9 +628,7 @@ describe("Anthropic Messages route", () => {
        { type: "reasoning", text: "", providerMetadata: { anthropic: { signature: "sig_1" } } },
      ])

-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({ model, messages: [response.message], cache: "none" }),
-      )
+      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message], cache: "none" }))
      expect(prepared.body.messages).toEqual([
        { role: "assistant", content: [{ type: "thinking", thinking: "", signature: "sig_1" }] },
      ])
@@ -773,7 +771,7 @@ describe("Anthropic Messages route", () => {
          ),
        ),
      )
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -1133,7 +1131,7 @@ describe("Anthropic Messages route", () => {

  it.effect("round-trips provider-executed assistant content into server tool blocks", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_round_trip",
          model,
@@ -1184,7 +1182,7 @@ describe("Anthropic Messages route", () => {

  it.effect("rejects round-trip for unknown server tool names", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_unknown_server_tool",
          model,
@@ -1261,7 +1259,7 @@ describe("Anthropic Messages route", () => {

  it.effect("maps ttlSeconds >= 3600 to cache_control ttl: '1h'", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          system: { type: "text", text: "system", cache: new CacheHint({ type: "ephemeral", ttlSeconds: 3600 }) },
@@ -1277,7 +1275,7 @@ describe("Anthropic Messages route", () => {

  it.effect("emits cache_control on tool definitions and tool-result blocks", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          tools: [
@@ -1318,7 +1316,7 @@ describe("Anthropic Messages route", () => {
  it.effect("drops cache_control breakpoints past the 4-per-request cap", () =>
    Effect.gen(function* () {
      const hint = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          system: [
@@ -1344,7 +1342,7 @@ describe("Anthropic Messages route", () => {
  it.effect("spends breakpoint budget on tools before system before messages", () =>
    Effect.gen(function* () {
      const hint = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          tools: [
@@ -13,6 +13,7 @@ import {
  ToolDefinition,
 } from "../../src"
 import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { AmazonBedrock } from "../../src/providers"
 import * as BedrockConverse from "../../src/protocols/bedrock-converse"
 import { it } from "../lib/effect"
@@ -101,7 +102,7 @@ const baseRequest = LLM.request({
 describe("Bedrock Converse route", () => {
  it.effect("prepares Converse target with system, inference config, and messages", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(baseRequest)
+      const prepared = yield* compileRequest(baseRequest)

      expect(prepared.body).toEqual({
        modelId: "anthropic.claude-3-5-sonnet-20240620-v1:0",
@@ -114,7 +115,7 @@ describe("Bedrock Converse route", () => {

  it.effect("passes topK through additionalModelRequestFields as top_k", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLMRequest.update(baseRequest, {
          generation: GenerationOptions.make({ maxTokens: 64, temperature: 0, topK: 40 }),
        }),
@@ -129,14 +130,14 @@ describe("Bedrock Converse route", () => {

  it.effect("omits additionalModelRequestFields when topK is unset", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(baseRequest)
+      const prepared = yield* compileRequest(baseRequest)
      expect(prepared.body.additionalModelRequestFields).toBeUndefined()
    }),
  )

  it.effect("lowers chronological system updates to wrapped user text in order", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [Message.user("Before."), Message.system("Update."), Message.assistant("After.")],
@@ -153,7 +154,7 @@ describe("Bedrock Converse route", () => {

  it.effect("prepares tool config with toolSpec and toolChoice", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(baseRequest, {
          tools: [
            ToolDefinition.make({
@@ -187,7 +188,7 @@ describe("Bedrock Converse route", () => {

  it.effect("keeps tools and omits the unsupported choice when tool choice is none", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(baseRequest, {
          tools: [
            ToolDefinition.make({
@@ -217,7 +218,7 @@ describe("Bedrock Converse route", () => {

  it.effect("lowers assistant tool-call + tool-result message history", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_history",
          model,
@@ -256,7 +257,7 @@ describe("Bedrock Converse route", () => {

  it.effect("lowers image content in tool-result messages", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_image",
          model,
@@ -491,7 +492,7 @@ describe("Bedrock Converse route", () => {
        providerMetadata: { bedrock: { signature: "sig_1" } },
      })

-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -546,9 +547,7 @@ describe("Bedrock Converse route", () => {
        },
      ])

-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
-        LLM.request({ model, messages: [response.message], cache: "none" }),
-      )
+      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message], cache: "none" }))
      expect(prepared.body.messages).toEqual([
        {
          role: "assistant",
@@ -639,7 +638,7 @@ describe("Bedrock Converse route", () => {
        text: "",
        providerMetadata: { bedrock: { redactedData } },
      })
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -754,7 +753,7 @@ describe("Bedrock Converse route", () => {
          secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
        },
      }).model("anthropic.claude-3-5-sonnet-20240620-v1:0")
-      const prepared = yield* LLMClient.prepare(LLMRequest.update(baseRequest, { model: signed }))
+      const prepared = yield* compileRequest(LLMRequest.update(baseRequest, { model: signed }))

      expect(prepared.route).toBe("bedrock-converse")
      expect(prepared.model).toBe(signed)
@@ -764,7 +763,7 @@ describe("Bedrock Converse route", () => {
  it.effect("emits cachePoint markers after system, user-text, and assistant-text with cache hints", () =>
    Effect.gen(function* () {
      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_cache",
          model,
@@ -796,7 +795,7 @@ describe("Bedrock Converse route", () => {

  it.effect("does not emit cachePoint when no cache hint is set", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(baseRequest)
+      const prepared = yield* compileRequest(baseRequest)
      expect(prepared.body).toMatchObject({
        system: [{ text: "You are concise." }],
        messages: [{ role: "user", content: [{ text: "Say hello." }] }],
@@ -806,7 +805,7 @@ describe("Bedrock Converse route", () => {

  it.effect("lowers image media into Bedrock image blocks", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_image",
          model,
@@ -843,7 +842,7 @@ describe("Bedrock Converse route", () => {

  it.effect("base64-encodes Uint8Array image bytes", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_image_bytes",
          model,
@@ -865,7 +864,7 @@ describe("Bedrock Converse route", () => {

  it.effect("lowers document media into Bedrock document blocks with format and name", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_doc",
          model,
@@ -897,7 +896,7 @@ describe("Bedrock Converse route", () => {

  it.effect("requires names for document media", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model,
          messages: [Message.user({ type: "media", mediaType: "application/pdf", data: "UERGREFUQQ==" })],
@@ -910,7 +909,7 @@ describe("Bedrock Converse route", () => {

  it.effect("passes named document-only messages through for provider validation", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          cache: "none",
@@ -936,7 +935,7 @@ describe("Bedrock Converse route", () => {

  it.effect("lowers document media in tool results", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<BedrockConverse.BedrockConverseBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          cache: "none",
@@ -988,7 +987,7 @@ describe("Bedrock Converse route", () => {

  it.effect("rejects unsupported image media types", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_bad_image",
          model,
@@ -1002,7 +1001,7 @@ describe("Bedrock Converse route", () => {

  it.effect("rejects unsupported document media types", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_bad_doc",
          model,
@@ -1017,7 +1016,7 @@ describe("Bedrock Converse route", () => {
  it.effect("maps ttlSeconds >= 3600 to cachePoint ttl: '1h'", () =>
    Effect.gen(function* () {
      const cache = new CacheHint({ type: "ephemeral", ttlSeconds: 3600 })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          system: [{ type: "text", text: "system", cache }],
@@ -1034,7 +1033,7 @@ describe("Bedrock Converse route", () => {
  it.effect("appends cachePoint after marked tool definitions and tool-result blocks", () =>
    Effect.gen(function* () {
      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          tools: [{ name: "lookup", description: "lookup", inputSchema: { type: "object", properties: {} }, cache }],
@@ -1066,7 +1065,7 @@ describe("Bedrock Converse route", () => {
  it.effect("drops cachePoint markers past the 4-per-request cap", () =>
    Effect.gen(function* () {
      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          system: [
@@ -3,7 +3,7 @@ import { ConfigProvider, Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMEvent } from "../../src"
 import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare"
-import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { it } from "../lib/effect"
 import { dynamicResponse } from "../lib/http"
 import { sseEvents } from "../lib/sse"
@@ -34,7 +34,7 @@ describe("Cloudflare", () => {
      })
      expect(model.route.endpoint.baseURL).toBe("https://gateway.ai.cloudflare.com/v1/test-account/test-gateway/compat")

-      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Say hello." }))
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Say hello." }))

      expect(prepared.route).toBe("cloudflare-ai-gateway")
      expect(prepared.body).toMatchObject({
@@ -129,7 +129,7 @@ describe("Cloudflare", () => {
        openai: { reasoningField: "reasoning", reasoningDetails: merged },
      })

-      const replay = yield* LLMClient.prepare(LLM.request({ model, messages: [response.message] }))
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([
        { role: "assistant", content: "Hello", reasoning: "Thinking", reasoning_details: merged },
      ])
@@ -180,7 +180,7 @@ describe("Cloudflare", () => {

  it.effect("allows a fully configured baseURL override", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: CloudflareAIGateway.configure({
            baseURL: "https://gateway.proxy.test/v1/custom/compat",
@@ -208,7 +208,7 @@ describe("Cloudflare", () => {
      })
      expect(model.route.endpoint.baseURL).toBe("https://api.cloudflare.com/client/v4/accounts/test-account/ai/v1")

-      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Say hello." }))
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Say hello." }))

      expect(prepared.route).toBe("cloudflare-workers-ai")
      expect(prepared.body).toMatchObject({
@@ -2,6 +2,7 @@ import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { LLM, LLMError, LLMRequest, Message, ToolCallPart, ToolDefinition, Usage } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import * as Gemini from "../../src/protocols/gemini"
 import { ProviderShared } from "../../src/protocols/shared"
 import { it } from "../lib/effect"
@@ -26,7 +27,7 @@ const request = LLM.request({
 describe("Gemini route", () => {
  it.effect("prepares Gemini target", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(request)
+      const prepared = yield* compileRequest(request)

      expect(prepared.body).toEqual({
        contents: [{ role: "user", parts: [{ text: "Say hello." }] }],
@@ -38,12 +39,12 @@ describe("Gemini route", () => {

  it.effect("normalizes Gemini thinking options", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { gemini: { thinkingConfig: { thinkingBudget: 0, includeThoughts: false } } },
        }),
      )
-      const filtered = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const filtered = yield* compileRequest(
        LLMRequest.update(request, {
          providerOptions: { gemini: { thinkingConfig: { thinkingBudget: "invalid", includeThoughts: false } } },
        }),
@@ -59,7 +60,7 @@ describe("Gemini route", () => {

  it.effect("lowers chronological system updates to wrapped user text in order", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [Message.user("Before."), Message.system("Update."), Message.assistant("After.")],
@@ -75,7 +76,7 @@ describe("Gemini route", () => {

  it.effect("prepares multimodal user input and tool history", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result",
          model,
@@ -143,7 +144,7 @@ describe("Gemini route", () => {

  it.effect("continues media tool results as inline model input without base64 text", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -188,7 +189,7 @@ describe("Gemini route", () => {

  it.effect("strips matching data URLs to raw base64 inlineData", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -229,7 +230,7 @@ describe("Gemini route", () => {
  ] as const)
    it.effect(`rejects ${name}`, () =>
      Effect.gen(function* () {
-        const error = yield* LLMClient.prepare(
+        const error = yield* compileRequest(
          LLM.request({ model, messages: [Message.user({ type: "media", ...media })] }),
        ).pipe(Effect.flip)
        expect(error.message).toMatch(/does not support|does not match|valid base64/)
@@ -238,7 +239,7 @@ describe("Gemini route", () => {

  it.effect("rejects oversized image input", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -256,7 +257,7 @@ describe("Gemini route", () => {

  it.effect("keeps tools and sends function calling mode NONE", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_choice_none",
          model,
@@ -276,7 +277,7 @@ describe("Gemini route", () => {

  it.effect("sanitizes integer enums, dangling required, untyped arrays, and scalar object keys", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_schema_patch",
          model,
@@ -457,7 +458,7 @@ describe("Gemini route", () => {
        response.events.findIndex((event) => event.type === "tool-call"),
      )

-      const prepared = yield* LLMClient.prepare<Gemini.GeminiBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -691,7 +692,7 @@ describe("Gemini route", () => {

  it.effect("rejects unsupported assistant media content", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_media",
          model,
@@ -4,6 +4,7 @@ import { HttpClientRequest } from "effect/unstable/http"
 import { LLM } from "../../src"
 import { GoogleVertex, GoogleVertexChat, GoogleVertexMessages, GoogleVertexResponses } from "../../src/providers"
 import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { it } from "../lib/effect"
 import { dynamicResponse } from "../lib/http"
 import { deltaChunk, finishChunk } from "../lib/openai-chunks"
@@ -182,7 +183,7 @@ describe("Google Vertex providers", () => {

  it.effect("protects the Vertex Messages API version from body overlays", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model: GoogleVertexMessages.configure({
            accessToken: "vertex-token",
@@ -5,6 +5,7 @@ import { OpenAIChat } from "../../src/protocols/openai-chat"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenRouter from "../../src/providers/openrouter"
 import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { recordedTests } from "../recorded-test"
 import { expectWeatherToolLoop, goldenWeatherToolLoopRequest, runWeatherToolLoop } from "../recorded-scenarios"

@@ -84,9 +85,7 @@ for (const item of cases) {
            ),
          ).toBe(true)

-          const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-            LLM.request({ model: item.model, messages: [response.message] }),
-          )
+          const replay = yield* compileRequest(LLM.request({ model: item.model, messages: [response.message] }))
          expect(replay.body.messages).toMatchObject([
            { role: "assistant", content: response.text, reasoning: response.reasoning },
          ])
@@ -18,6 +18,7 @@ import * as OpenAI from "../../src/providers/openai"
 import * as OpenAIChat from "../../src/protocols/openai-chat"
 import { ProviderShared } from "../../src/protocols/shared"
 import { Auth, LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { it } from "../lib/effect"
 import { dynamicResponse, fixedResponse, truncatedStream } from "../lib/http"
 import { deltaChunk, usageChunk } from "../lib/openai-chunks"
@@ -42,11 +43,7 @@ const request = LLM.request({
 describe("OpenAI Chat route", () => {
  it.effect("prepares OpenAI Chat payload", () =>
    Effect.gen(function* () {
-      // Pass the OpenAIChat payload type so `prepared.body` is statically
-      // typed to the route's native shape — the assertions below read field
-      // names without `unknown` casts.
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(request)
-      const _typed: { readonly model: string; readonly stream: true } = prepared.body
+      const prepared = yield* compileRequest(request)

      expect(prepared.body).toEqual({
        model: "gpt-4o-mini",
@@ -64,7 +61,7 @@ describe("OpenAI Chat route", () => {

  it.effect("lowers chronological system updates to escaped user wrappers in order", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -87,7 +84,7 @@ describe("OpenAI Chat route", () => {

  it.effect("replays canonical reasoning as OpenAI-compatible reasoning_content", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -105,7 +102,7 @@ describe("OpenAI Chat route", () => {

  it.effect("writes reasoning to a configured custom field on every assistant message", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: Model.update(model, { compatibility: { reasoningField: "vendor_reasoning" } }),
          messages: [
@@ -131,7 +128,7 @@ describe("OpenAI Chat route", () => {

  it.effect("rejects reasoning fields that conflict with assistant message fields", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model: Model.update(model, { compatibility: { reasoningField: "content" } }),
          messages: [Message.assistant([{ type: "reasoning", text: "thinking" }])],
@@ -144,7 +141,7 @@ describe("OpenAI Chat route", () => {

  it.effect("maps OpenAI provider options to Chat options", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).chat("gpt-4o-mini"),
          prompt: "think",
@@ -159,7 +156,7 @@ describe("OpenAI Chat route", () => {

  it.effect("passes through custom OpenAI-compatible reasoning effort strings", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "think",
@@ -253,7 +250,7 @@ describe("OpenAI Chat route", () => {

  it.effect("prepares assistant tool-call and tool-result messages", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result",
          model,
@@ -291,7 +288,7 @@ describe("OpenAI Chat route", () => {
  it.effect("preserves structured tool errors for the model", () =>
    Effect.gen(function* () {
      const error = { error: { type: "unknown", message: "Tool execution interrupted" } }
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -311,7 +308,7 @@ describe("OpenAI Chat route", () => {

  it.effect("continues image tool results as vision input without base64 text", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -355,7 +352,7 @@ describe("OpenAI Chat route", () => {

  it.effect("orders parallel tool responses before one aggregated vision message", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -405,7 +402,7 @@ describe("OpenAI Chat route", () => {

  it.effect("aggregates consecutive tool images with a following system update", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -446,7 +443,7 @@ describe("OpenAI Chat route", () => {

  it.effect("appends system updates without replacing multipart user content", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -474,7 +471,7 @@ describe("OpenAI Chat route", () => {
  ] as const)
    it.effect(`rejects ${name}`, () =>
      Effect.gen(function* () {
-        const error = yield* LLMClient.prepare(
+        const error = yield* compileRequest(
          LLM.request({ model, messages: [Message.user({ type: "media", ...media })] }),
        ).pipe(Effect.flip)
        expect(error.message).toMatch(/does not support|does not match|valid base64/)
@@ -483,7 +480,7 @@ describe("OpenAI Chat route", () => {

  it.effect("rejects oversized image input", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -501,7 +498,7 @@ describe("OpenAI Chat route", () => {

  it.effect("prepares raw and data URL image media as vision input", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_media",
          model,
@@ -528,7 +525,7 @@ describe("OpenAI Chat route", () => {

  it.effect("lowers reasoning-only assistant history", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_reasoning",
          model,
@@ -619,9 +616,7 @@ describe("OpenAI Chat route", () => {
          openai: { reasoningField: field },
        })

-        const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-          LLM.request({ model, messages: [response.message] }),
-        )
+        const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
        expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", [field]: "thinking" }])
      }
    }),
@@ -647,9 +642,7 @@ describe("OpenAI Chat route", () => {
        openai: { reasoningField: "vendor_reasoning" },
      })

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model: custom, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model: custom, messages: [response.message] }))
      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", vendor_reasoning: "thinking" }])
    }),
  )
@@ -692,9 +685,7 @@ describe("OpenAI Chat route", () => {
        openai: { reasoningField: "reasoning", reasoningDetails: details },
      })

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([
        {
          role: "assistant",
@@ -737,9 +728,7 @@ describe("OpenAI Chat route", () => {
        openai: { reasoningDetails: details },
      })

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", reasoning_details: details }])
    }),
  )
@@ -764,9 +753,7 @@ describe("OpenAI Chat route", () => {
        openai: { reasoningField: "reasoning", reasoningDetails: details },
      })

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([
        { role: "assistant", content: "Hello", reasoning: "thinking", reasoning_details: details },
      ])
@@ -839,9 +826,7 @@ describe("OpenAI Chat route", () => {
        openai: { reasoningDetails: [] },
      })

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", reasoning_details: [] }])
    }),
  )
@@ -889,9 +874,7 @@ describe("OpenAI Chat route", () => {
        response.events.findIndex(LLMEvent.is.textStart),
      )

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([
        { role: "assistant", content: "Hello", reasoning: "thinking", reasoning_details: merged },
      ])
@@ -918,9 +901,7 @@ describe("OpenAI Chat route", () => {
      expect(response.events.filter(LLMEvent.is.reasoningStart)).toHaveLength(1)
      expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)

-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(replay.body.messages).toEqual([{ role: "assistant", content: null, reasoning_details: details }])
    }),
  )
@@ -950,7 +931,7 @@ describe("OpenAI Chat route", () => {
    Effect.gen(function* () {
      const first = { type: "reasoning.text", text: "first", signature: "signed-0", index: 0 }
      const second = { type: "reasoning.text", text: "second", signature: "signed-1", index: 1 }
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const replay = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -979,7 +960,7 @@ describe("OpenAI Chat route", () => {
  it.effect("retains scalar replay for mixed structured reasoning parts", () =>
    Effect.gen(function* () {
      const detail = { type: "reasoning.encrypted", data: "opaque", index: 0 }
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const replay = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -1004,7 +985,7 @@ describe("OpenAI Chat route", () => {
  it.effect("replays native scalar reasoning alongside native details", () =>
    Effect.gen(function* () {
      const details = [{ type: "reasoning.encrypted", data: "opaque", index: 0 }]
-      const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const replay = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -3,6 +3,7 @@ import { Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src"
 import { Auth, LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import * as OpenAICompatible from "../../src/providers/openai-compatible"
 import * as OpenAICompatibleChat from "../../src/protocols/openai-compatible-chat"
 import { it } from "../lib/effect"
@@ -52,7 +53,7 @@ const providerFamilies = [
 describe("OpenAI-compatible Chat route", () => {
  it.effect("prepares generic Chat target", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, {
          tools: [ToolDefinition.make({ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } })],
          toolChoice: ToolChoice.make({ type: "required" }),
@@ -127,7 +128,7 @@ describe("OpenAI-compatible Chat route", () => {

  it.effect("matches AI SDK compatible basic request body fixture", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(request)
+      const prepared = yield* compileRequest(request)

      expect(prepared.body).toEqual({
        model: "deepseek-chat",
@@ -145,7 +146,7 @@ describe("OpenAI-compatible Chat route", () => {

  it.effect("matches AI SDK compatible tool request body fixture", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_parity",
          model,
@@ -7,6 +7,7 @@ import { OpenResponses } from "../../src/protocols/open-responses"
 import { OpenAICompatibleResponses } from "../../src/protocols/openai-compatible-responses"
 import { OpenAIResponses } from "../../src/protocols/openai-responses"
 import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import { it } from "../lib/effect"
 import { fixedResponse } from "../lib/http"
 import { sseEvents } from "../lib/sse"
@@ -23,7 +24,7 @@ describe("Open Responses-compatible route", () => {
        baseURL: "https://responses.example.test/v1",
        provider: "example",
      }).model("example-model")
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          system: "You are concise.",
@@ -61,7 +62,7 @@ describe("Open Responses-compatible route", () => {
        apiKey: "test-key",
        baseURL: "https://responses.example.test/v1",
      }).model("example-model")
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({ model, prompt: "Draw.", tools: [OpenAI.imageGeneration()] }),
      ).pipe(Effect.flip)

@@ -76,7 +77,7 @@ describe("Open Responses-compatible route", () => {
        apiKey: "test-key",
        baseURL: "https://responses.example.test/v1",
      }).model("example-model")
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -102,7 +103,7 @@ describe("Open Responses-compatible route", () => {
        baseURL: "https://responses.example.test/v1",
        providerOptions: { openresponses: { reasoningEffort: "low", store: true } },
      }).model("example-model")
-      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Think." }))
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Think." }))

      expect(prepared.body).toMatchObject({
        reasoning: { effort: "low" },
@@ -14,6 +14,7 @@ import {
  Usage,
 } from "../../src"
 import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
 import * as XAI from "../../src/providers/xai"
@@ -56,7 +57,7 @@ const expectToolOutput = (body: OpenAIResponses.OpenAIResponsesBody): OpenAITool
 describe("OpenAI Responses route", () => {
  it.effect("prepares OpenAI Responses target", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(request)
+      const prepared = yield* compileRequest(request)

      expect(prepared.body).toEqual({
        model: "gpt-4.1-mini",
@@ -74,7 +75,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lowers the hosted OpenAI image generation tool", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "Show me a rooftop garden.",
@@ -92,7 +93,7 @@ describe("OpenAI Responses route", () => {

  it.effect("rejects invalid hosted image generation options locally", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          model,
          prompt: "Show me a rooftop garden.",
@@ -109,7 +110,7 @@ describe("OpenAI Responses route", () => {
    Effect.gen(function* () {
      const input = LLMRequest.update(request, { providerOptions: { openai: { serviceTier: "priority" } } })
      expect(input.providerOptions).toEqual({ openai: { serviceTier: "priority" } })
-      const prepared = yield* LLMClient.prepare(input)
+      const prepared = yield* compileRequest(input)

      expect(prepared.body).toMatchObject({ service_tier: "priority" })
      expect(prepared.body).not.toHaveProperty("serviceTier")
@@ -118,7 +119,7 @@ describe("OpenAI Responses route", () => {

  it.effect("passes through custom OpenAI reasoning effort strings", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, { providerOptions: { openai: { reasoningEffort: "experimental" } } }),
      )

@@ -128,7 +129,7 @@ describe("OpenAI Responses route", () => {

  it.effect("omits unsupported semantic service tiers", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, { providerOptions: { openai: { serviceTier: "unsupported" } } }),
      )

@@ -138,7 +139,7 @@ describe("OpenAI Responses route", () => {

  it.effect("flattens top-level object unions in function schemas", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, {
          tools: [
            ToolDefinition.make({
@@ -191,7 +192,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lowers chronological system updates to escaped user wrappers in order", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -217,7 +218,7 @@ describe("OpenAI Responses route", () => {

  it.effect("prepares OpenAI Responses WebSocket target", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLMRequest.update(request, {
          model: OpenAIResponses.webSocketRoute
            .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
@@ -395,7 +396,7 @@ describe("OpenAI Responses route", () => {

  it.effect("prepares function call and function output input items", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result",
          model,
@@ -432,7 +433,7 @@ describe("OpenAI Responses route", () => {
        content: [],
        structured: {},
      }
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -453,7 +454,7 @@ describe("OpenAI Responses route", () => {

  it.effect("keeps primitive tool errors as plain text", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -469,7 +470,7 @@ describe("OpenAI Responses route", () => {

  it.effect("keeps non-JSON tool errors as plain text", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -487,7 +488,7 @@ describe("OpenAI Responses route", () => {
  // image data is not JSON-stringified into `function_call_output.output`.
  it.effect("lowers image tool-result content as structured input_image items", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_image",
          model,
@@ -516,7 +517,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lowers single-image tool-result content as structured input_image array", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_image_only",
          model,
@@ -540,7 +541,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lowers PDF tool-result content as structured input_file array", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_pdf",
          model,
@@ -575,7 +576,7 @@ describe("OpenAI Responses route", () => {

  it.effect("uses xAI inline file encoding for PDF tool results", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: xaiModel,
          messages: [
@@ -610,7 +611,7 @@ describe("OpenAI Responses route", () => {

  it.effect("rejects unsupported media in tool-result content with a clear error", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_tool_result_unsupported_media",
          model,
@@ -633,7 +634,7 @@ describe("OpenAI Responses route", () => {

  it.effect("prepares the composed native continuation request", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        continuationRequest({
          id: "req_native_continuation_openai",
          model,
@@ -675,7 +676,7 @@ describe("OpenAI Responses route", () => {

  it.effect("maps OpenAI provider options to Responses options", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).model("gpt-5.2"),
          prompt: "think",
@@ -700,7 +701,7 @@ describe("OpenAI Responses route", () => {

  it.effect("accepts the full ResponseIncludable union", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "hi",
@@ -722,7 +723,7 @@ describe("OpenAI Responses route", () => {

  it.effect("filters unknown includable values out of the include array", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "hi",
@@ -739,7 +740,7 @@ describe("OpenAI Responses route", () => {

  it.effect("treats an explicit empty include as no include at all", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({ model, prompt: "hi", providerOptions: { openai: { include: [] } } }),
      )

@@ -749,7 +750,7 @@ describe("OpenAI Responses route", () => {

  it.effect("treats an all-invalid include as no include at all", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({ model, prompt: "hi", providerOptions: { openai: { include: ["bogus.thing"] } } }),
      )

@@ -759,7 +760,7 @@ describe("OpenAI Responses route", () => {

  it.effect("omits include when no include is set", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({ model, prompt: "hi", providerOptions: { openai: { store: false } } }),
      )

@@ -773,7 +774,7 @@ describe("OpenAI Responses route", () => {
      // reasoningSummary: "auto" by default. Without `include`, a follow-up
      // turn cannot replay reasoning state, so the facade also opts into
      // `reasoning.encrypted_content` automatically.
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-5.2"),
          prompt: "hi",
@@ -788,7 +789,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lets callers opt out of the GPT-5 default include", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-5.2"),
          prompt: "hi",
@@ -802,7 +803,7 @@ describe("OpenAI Responses route", () => {

  it.effect("request OpenAI provider options override route defaults", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenAI.configure({
            baseURL: "https://api.openai.test/v1/",
@@ -934,9 +935,7 @@ describe("OpenAI Responses route", () => {
        },
      ])

-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
-        LLM.request({ model, messages: [response.message] }),
-      )
+      const prepared = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
      expect(prepared.body.input).toEqual([
        {
          role: "assistant",
@@ -1270,7 +1269,7 @@ describe("OpenAI Responses route", () => {

  it.effect("preserves assistant content order around reasoning items", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_reasoning_order",
          model,
@@ -1308,7 +1307,7 @@ describe("OpenAI Responses route", () => {

  it.effect("references stored reasoning items by id", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -1330,7 +1329,7 @@ describe("OpenAI Responses route", () => {

  it.effect("references stored provider-executed hosted tool results by id", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -1367,7 +1366,7 @@ describe("OpenAI Responses route", () => {
  it.effect("continues stateless hosted image generation with the generated image", () =>
    Effect.gen(function* () {
      const imageTool = OpenAI.imageGeneration({ action: "edit" })
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          messages: [
@@ -1408,7 +1407,7 @@ describe("OpenAI Responses route", () => {

  it.effect("joins streamed summary blocks into one continuation reasoning item", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_multi_summary_continuation",
          model,
@@ -1445,7 +1444,7 @@ describe("OpenAI Responses route", () => {

  it.effect("skips non-persisted reasoning ids without encrypted state", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_reasoning_without_encrypted_state",
          model,
@@ -1762,7 +1761,7 @@ describe("OpenAI Responses route", () => {

  it.effect("lowers user image and PDF content", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          id: "req_media",
          model,
@@ -1793,7 +1792,7 @@ describe("OpenAI Responses route", () => {

  it.effect("uses xAI inline file encoding for user PDFs", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenAIResponses.OpenAIResponsesBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: xaiModel,
          messages: [
@@ -1825,7 +1824,7 @@ describe("OpenAI Responses route", () => {

  it.effect("rejects unsupported user media content", () =>
    Effect.gen(function* () {
-      const error = yield* LLMClient.prepare(
+      const error = yield* compileRequest(
        LLM.request({
          id: "req_media",
          model,
@@ -2,6 +2,7 @@ import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { LLM, Message } from "../../src"
 import { LLMClient } from "../../src/route"
+import { compileRequest } from "../../src/route/client"
 import * as OpenRouter from "../../src/providers/openrouter"
 import { it } from "../lib/effect"
 import { fixedResponse } from "../lib/http"
@@ -19,7 +20,7 @@ describe("OpenRouter", () => {
      })
      expect(model.route.endpoint.baseURL).toBe("https://openrouter.ai/api/v1")

-      const prepared = yield* LLMClient.prepare(LLM.request({ model, prompt: "Say hello." }))
+      const prepared = yield* compileRequest(LLM.request({ model, prompt: "Say hello." }))

      expect(prepared.route).toBe("openrouter")
      expect(prepared.body).toMatchObject({
@@ -32,7 +33,7 @@ describe("OpenRouter", () => {

  it.effect("applies OpenRouter payload options from the model helper", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenRouter.configure({
            apiKey: "test-key",
@@ -100,7 +101,7 @@ describe("OpenRouter", () => {
        { type: "reasoning.text", signature: "signed", format: "anthropic-claude-v1", index: 0 },
        { type: "reasoning.encrypted", data: "opaque", format: "openai-responses-v1", index: 1 },
      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
          messages: [
@@ -133,7 +134,7 @@ describe("OpenRouter", () => {
        { type: "reasoning.encrypted", id: "state", data: "opaque" },
        { type: "reasoning.encrypted", id: "state", data: "opaque" },
      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
          messages: [
@@ -158,7 +159,7 @@ describe("OpenRouter", () => {
        { type: "reasoning.text", id: "first", index: 0, text: "A", opaque: "first" },
        { type: "reasoning.text", id: "second", index: 1, text: "B", opaque: "second" },
      ]
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
          messages: [
@@ -179,7 +180,7 @@ describe("OpenRouter", () => {

  it.effect("omits scalar reasoning without continuation details", () =>
    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare<OpenRouter.OpenRouterBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model: OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6"),
          messages: [Message.assistant({ type: "reasoning", text: "Thinking" })],
@@ -3,7 +3,8 @@ import { Effect } from "effect"
 import { LLM } from "../src"
 import { OpenAIChat } from "../src/protocols"
 import { ToolSchemaProjection } from "../src/protocols/utils/tool-schema"
-import { Auth, LLMClient } from "../src/route"
+import { Auth } from "../src/route"
+import { compileRequest } from "../src/route/client"
 import { it } from "./lib/effect"

 describe("tool schema projections", () => {
@@ -79,7 +80,7 @@ describe("tool schema projections", () => {
      const model = OpenAIChat.route
        .with({ endpoint: { baseURL: "https://api.openai.test/v1/" }, auth: Auth.bearer("test") })
        .model({ id: "kimi-k2", compatibility: { toolSchema: "moonshot" } })
-      const prepared = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
+      const prepared = yield* compileRequest(
        LLM.request({
          model,
          prompt: "Use the tool.",
@@ -69,7 +69,7 @@ export const DialogFork: Component = () => {
    const dir = base64Encode(sdk().directory)

    sdk()
-      .api.session.fork({ sessionID, messageID: item.id })
+      .api.session.fork({ sessionID, boundary: { type: "before", messageID: item.id } })
      .then((forked) => {
        dialog.close()
        prompt.set(restored, undefined, { dir, id: forked.id })
@@ -1,133 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createRoot } from "solid-js"
-import { createStore } from "solid-js/store"
-import { SESSION_OPEN_FILE_TAB } from "./helpers"
-import { createSessionSidePanelController, sessionSidePanelHandoffFiles } from "./session-side-panel-controller"
-
-function createController(options?: { active?: string; all?: string[]; mode?: "changes" | "all" }) {
-  const calls: string[] = []
-  const [state, setState] = createStore({
-    active: options?.active,
-    all: options?.all ?? ["file://src/a.ts"],
-    preview: undefined as string | undefined,
-    mode: options?.mode ?? ("changes" as "changes" | "all"),
-  })
-  return createRoot((dispose) => ({
-    dispose,
-    calls,
-    state,
-    controller: createSessionSidePanelController({
-      currentTab: () => state.active,
-      allTabs: () => state.all,
-      openTab: (tab) => calls.push(`open:${tab}`),
-      preview: (tab) => calls.push(`preview:${tab}`),
-      setActive: (tab) => calls.push(`active:${tab}`),
-      normalizeFileTab: (tab) => `file://${tab.slice("file://".length).toLowerCase()}`,
-      pathFromTab: (tab) => (tab.startsWith("file://") ? tab.slice("file://".length) : undefined),
-      loadFile: (path) => calls.push(`load:${path}`),
-      reviewEnabled: () => true,
-      canReview: () => true,
-      fileBrowserEnabled: () => true,
-      reviewPanelOpened: () => false,
-      openReviewPanel: () => calls.push("panel"),
-      treeMode: () => state.mode,
-      setTreeMode: (mode) => setState("mode", mode),
-      fileReady: () => false,
-      sessionKey: () => "session",
-      selectedLines: () => null,
-      persistHandoff: () => undefined,
-      showDialog: () => undefined,
-    }),
-  }))
-}
-
-describe("session side panel controller", () => {
-  test("normalizes and centralizes file tab selection mutations", async () => {
-    const owned = createController()
-
-    owned.controller.tabs.activate("file://SRC/A.ts")
-    expect(owned.calls).toEqual(["load:src/a.ts", "panel", "active:file://src/a.ts"])
-
-    owned.calls.length = 0
-    owned.controller.tabs.preview("file://SRC/B.ts")
-    expect(owned.calls).toEqual(["preview:file://src/b.ts", "load:src/b.ts", "panel"])
-    await Promise.resolve()
-    expect(owned.calls).toEqual(["preview:file://src/b.ts", "load:src/b.ts", "panel", "active:file://src/b.ts"])
-
-    owned.calls.length = 0
-    owned.controller.tabs.open("file://SRC/C.ts")
-    expect(owned.calls).toEqual(["open:file://src/c.ts", "load:src/c.ts", "panel", "active:file://src/c.ts"])
-    owned.dispose()
-  })
-
-  test("derives browser selection and controls the tree mode", () => {
-    const owned = createController({ active: "file://src/a.ts", all: ["file://src/a.ts"] })
-
-    expect(owned.controller.browser.tab()).toBe("file://src/a.ts")
-    expect(owned.controller.browser.mounted()).toBe(true)
-    expect(owned.controller.browser.visible()).toBe(true)
-
-    owned.controller.tree.setMode("invalid")
-    expect(owned.state.mode).toBe("changes")
-    owned.controller.tree.showAll()
-    expect(owned.state.mode).toBe("all")
-    owned.controller.tree.showAll()
-    expect(owned.state.mode).toBe("all")
-
-    owned.calls.length = 0
-    owned.controller.browser.open()
-    expect(owned.calls[0]).toBe(`preview:${SESSION_OPEN_FILE_TAB}`)
-    owned.dispose()
-  })
-
-  test("opens the file dialog with the tree handoff callback", async () => {
-    let render: (() => unknown) | undefined
-    let dialogProps: { mode?: "files"; onOpenFile?: (path: string) => void } | undefined
-    const owned = createController()
-    const controller = createSessionSidePanelController({
-      currentTab: () => undefined,
-      allTabs: () => [],
-      openTab: () => undefined,
-      preview: () => undefined,
-      setActive: () => undefined,
-      normalizeFileTab: (tab) => tab,
-      pathFromTab: () => undefined,
-      loadFile: () => undefined,
-      reviewEnabled: () => true,
-      canReview: () => true,
-      fileBrowserEnabled: () => true,
-      reviewPanelOpened: () => true,
-      openReviewPanel: () => undefined,
-      treeMode: owned.controller.tree.mode,
-      setTreeMode: owned.controller.tree.setMode,
-      fileReady: () => false,
-      sessionKey: () => "session",
-      selectedLines: () => null,
-      persistHandoff: () => undefined,
-      showDialog: (value) => (render = value),
-      loadSelectFileDialog: async () => ({
-        DialogSelectFile: (props) => {
-          dialogProps = props
-          return null
-        },
-      }),
-    })
-
-    await controller.dialog.openFile()
-    render?.()
-    expect(dialogProps?.mode).toBe("files")
-    dialogProps?.onOpenFile?.("src/a.ts")
-    expect(owned.state.mode).toBe("all")
-    owned.dispose()
-  })
-})
-
-test("projects only file tabs into handoff persistence", () => {
-  expect(
-    sessionSidePanelHandoffFiles(
-      ["review", "file://src/a.ts", "file://src/b.ts"],
-      (tab) => (tab.startsWith("file://") ? tab.slice("file://".length) : undefined),
-      (path) => (path.endsWith("a.ts") ? { start: 2, end: 4 } : { startLine: 2, endLine: 4 }),
-    ),
-  ).toEqual({ "src/a.ts": { start: 2, end: 4 }, "src/b.ts": null })
-})
@@ -1,150 +0,0 @@
-import { createComponent, createEffect, createMemo, type Accessor, type Component, type JSX } from "solid-js"
-import type { SelectedLineRange } from "@/context/file"
-import { SESSION_OPEN_FILE_TAB, createOpenSessionFileTab, createSessionTabs } from "@/pages/session/helpers"
-
-type TreeMode = "changes" | "all"
-
-type Input = {
-  currentTab: Accessor<string | undefined>
-  allTabs: Accessor<string[]>
-  openTab: (tab: string) => void
-  preview: (tab: string) => void
-  setActive: (tab: string) => void
-  normalizeFileTab: (tab: string) => string
-  pathFromTab: (tab: string) => string | undefined
-  loadFile: (path: string) => void
-  reviewEnabled: Accessor<boolean>
-  canReview: Accessor<boolean>
-  fileBrowserEnabled: Accessor<boolean>
-  reviewPanelOpened: Accessor<boolean>
-  openReviewPanel: () => void
-  treeMode: Accessor<TreeMode>
-  setTreeMode: (mode: TreeMode) => void
-  fileReady: Accessor<boolean>
-  sessionKey: Accessor<string>
-  selectedLines: (path: string) => unknown
-  persistHandoff: (key: string, files: Record<string, SelectedLineRange | null>) => void
-  showDialog: (render: () => JSX.Element) => void
-  loadSelectFileDialog?: () => Promise<{
-    DialogSelectFile: Component<{ mode?: "files"; onOpenFile?: (path: string) => void }>
-  }>
-}
-
-export function createSessionSidePanelController(input: Input) {
-  const normalizeTab = (tab: string) => (tab.startsWith("file://") ? input.normalizeFileTab(tab) : tab)
-  const openReviewPanel = () => {
-    if (!input.reviewPanelOpened()) input.openReviewPanel()
-  }
-  const tabs = createSessionTabs({
-    tabs: () => ({ active: input.currentTab, all: input.allTabs }),
-    pathFromTab: input.pathFromTab,
-    normalizeTab,
-    review: input.reviewEnabled,
-    hasReview: input.canReview,
-    fileBrowser: input.fileBrowserEnabled,
-  })
-  const prepareTab = (tab: string) => {
-    const path = input.pathFromTab(tab)
-    if (path) input.loadFile(path)
-    openReviewPanel()
-    return tab
-  }
-  const open = createOpenSessionFileTab({
-    normalizeTab,
-    openTab: input.openTab,
-    pathFromTab: input.pathFromTab,
-    loadFile: input.loadFile,
-    openReviewPanel,
-    setActive: input.setActive,
-  })
-  const preview = (value: string) => {
-    const next = normalizeTab(value)
-    input.preview(next)
-    const selected = prepareTab(next)
-    queueMicrotask(() => input.setActive(selected))
-  }
-  const activate = (value: string) => input.setActive(prepareTab(normalizeTab(value)))
-  const openFileBrowser = () => preview(SESSION_OPEN_FILE_TAB)
-  const browserTab = createMemo(() => {
-    if (!input.fileBrowserEnabled()) return undefined
-    const active = tabs.activeTab()
-    if (active === SESSION_OPEN_FILE_TAB) return SESSION_OPEN_FILE_TAB
-    if (active && input.pathFromTab(active)) return active
-    return tabs.activeFileTab()
-  })
-  // Keep the shell mounted while any file tab exists. Kobalte briefly selects
-  // Review while replacing a preview trigger, which must not reset sidebar scroll.
-  const fileBrowserMounted = createMemo(
-    () =>
-      input.fileBrowserEnabled() && (tabs.openedTabs().length > 0 || tabs.openFileOpen() || browserTab() !== undefined),
-  )
-  const fileBrowserVisible = createMemo(() => {
-    const active = tabs.activeTab()
-    return active !== "review" && active !== "context" && active !== "empty"
-  })
-  const setTreeMode = (value: string) => {
-    if (value !== "changes" && value !== "all") return
-    input.setTreeMode(value)
-  }
-  const showAllFiles = () => {
-    if (input.treeMode() !== "changes") return
-    input.setTreeMode("all")
-  }
-  const openFileDialog = async () => {
-    const load = input.loadSelectFileDialog ?? (() => import("@/components/dialog-select-file"))
-    const { DialogSelectFile } = await load()
-    input.showDialog(() => createComponent(DialogSelectFile, { mode: "files", onOpenFile: showAllFiles }))
-  }
-
-  createEffect(() => {
-    if (!input.fileReady()) return
-    input.persistHandoff(
-      input.sessionKey(),
-      sessionSidePanelHandoffFiles(input.allTabs(), input.pathFromTab, input.selectedLines),
-    )
-  })
-
-  return {
-    tabs: {
-      ...tabs,
-      normalize: normalizeTab,
-      open,
-      preview,
-      activate,
-    },
-    browser: {
-      tab: browserTab,
-      mounted: fileBrowserMounted,
-      visible: fileBrowserVisible,
-      open: openFileBrowser,
-    },
-    tree: {
-      mode: input.treeMode,
-      setMode: setTreeMode,
-      showAll: showAllFiles,
-    },
-    dialog: {
-      openFile: openFileDialog,
-    },
-  }
-}
-
-export function sessionSidePanelHandoffFiles(
-  tabs: readonly string[],
-  pathFromTab: (tab: string) => string | undefined,
-  selectedLines: (path: string) => unknown,
-) {
-  return tabs.reduce<Record<string, SelectedLineRange | null>>((files, tab) => {
-    const path = pathFromTab(tab)
-    if (!path) return files
-    const selected = selectedLines(path)
-    files[path] = isSelectedLineRange(selected) ? selected : null
-    return files
-  }, {})
-}
-
-function isSelectedLineRange(value: unknown): value is SelectedLineRange {
-  return !!value && typeof value === "object" && "start" in value && "end" in value
-}
-
-export type SessionSidePanelController = ReturnType<typeof createSessionSidePanelController>
@@ -1,4 +1,4 @@
-import { For, Match, Show, Switch, createMemo, onCleanup, type JSX } from "solid-js"
+import { For, Match, Show, Switch, createEffect, createMemo, onCleanup, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
 import { createMediaQuery } from "@solid-primitives/media"
 import { DragDropProvider as DndKitProvider, PointerSensor } from "@dnd-kit/solid"
@@ -38,17 +38,23 @@ const fileBrowserTabPanelID = "session-side-panel-file-browser-tabpanel"
 import { SessionContextTab, SortableTab, SortableTabV2, FileVisual } from "@/components/session"
 import { OpenInAppV2 } from "@/components/session/open-in-app-v2"
 import { useCommand } from "@/context/command"
-import { useFile } from "@/context/file"
+import { useFile, type SelectedLineRange } from "@/context/file"
 import { useLanguage } from "@/context/language"
 import { useLayout } from "@/context/layout"
 import { useSDK } from "@/context/sdk"
 import { useSettings } from "@/context/settings"
 import { createFileTabListSync } from "@/pages/session/file-tab-scroll"
 import { FileTabContent } from "@/pages/session/file-tabs"
-import { SESSION_OPEN_FILE_TAB, getTabReorderIndex, shouldShowFileTree, type Sizing } from "@/pages/session/helpers"
+import {
+  SESSION_OPEN_FILE_TAB,
+  createOpenSessionFileTab,
+  createSessionTabs,
+  getTabReorderIndex,
+  shouldShowFileTree,
+  type Sizing,
+} from "@/pages/session/helpers"
 import { setSessionHandoff } from "@/pages/session/handoff"
 import { useSessionLayout } from "@/pages/session/session-layout"
-import { createSessionSidePanelController } from "@/pages/session/session-side-panel-controller"
 import { SessionFileBrowserTab, type SessionFileBrowserState } from "@/pages/session/v2/session-file-browser-tab"

 type ReviewDiff = FileDiffInfo | SnapshotFileDiff | VcsFileDiff
@@ -147,49 +153,91 @@ export function SessionSidePanel(props: {
    return file.tree.children("").length === 0
  })

-  const controller = createSessionSidePanelController({
-    currentTab: () => tabs().active(),
-    allTabs: () => tabs().all(),
-    openTab: (tab) => tabs().open(tab),
-    preview: (tab) => tabs().previewTab(tab),
-    setActive: (tab) => tabs().setActive(tab),
-    normalizeFileTab: file.tab,
+  const normalizeTab = (tab: string) => {
+    if (!tab.startsWith("file://")) return tab
+    return file.tab(tab)
+  }
+
+  const openReviewPanel = () => {
+    if (!view().reviewPanel.opened()) view().reviewPanel.open()
+  }
+
+  const openTab = createOpenSessionFileTab({
+    normalizeTab,
+    openTab: tabs().open,
    pathFromTab: file.pathFromTab,
    loadFile: file.load,
-    reviewEnabled: reviewTab,
-    canReview: props.canReview,
-    fileBrowserEnabled: () => !!props.fileBrowserState,
-    reviewPanelOpened: () => view().reviewPanel.opened(),
-    openReviewPanel: () => view().reviewPanel.open(),
-    treeMode: () => layout.fileTree.tab(),
-    setTreeMode: (mode) => layout.fileTree.setTab(mode),
-    fileReady: file.ready,
-    sessionKey,
-    selectedLines: file.selectedLines,
-    persistHandoff: (key, files) => setSessionHandoff(key, { files }),
-    showDialog: (render) => void dialog.show(render),
+    openReviewPanel,
+    setActive: tabs().setActive,
  })
-  const contextOpen = controller.tabs.contextOpen
-  const panelTabs = controller.tabs.panelTabs
-  const openedTabs = controller.tabs.openedTabs
-  const activeTab = controller.tabs.activeTab
-  const activeFileTab = controller.tabs.activeFileTab
-  const openTab = controller.tabs.open
-  const previewTab = controller.tabs.preview
-  const activateTab = controller.tabs.activate
-  const browserTab = controller.browser.tab
-  const fileBrowserMounted = controller.browser.mounted
-  const fileBrowserVisible = controller.browser.visible
-  const fileTreeTab = controller.tree.mode
-  const setFileTreeTabValue = controller.tree.setMode
+
+  const tabState = createSessionTabs({
+    tabs,
+    pathFromTab: file.pathFromTab,
+    normalizeTab,
+    review: reviewTab,
+    hasReview: props.canReview,
+    fileBrowser: () => !!props.fileBrowserState,
+  })
+  const contextOpen = tabState.contextOpen
+  const openFileOpen = tabState.openFileOpen
+  const panelTabs = tabState.panelTabs
+  const openedTabs = tabState.openedTabs
+  const activeTab = tabState.activeTab
+  const activeFileTab = tabState.activeFileTab
+
+  const fileTreeTab = () => layout.fileTree.tab()
+
+  const setFileTreeTabValue = (value: string) => {
+    if (value !== "changes" && value !== "all") return
+    layout.fileTree.setTab(value)
+  }
+
+  const showAllFiles = () => {
+    if (fileTreeTab() !== "changes") return
+    layout.fileTree.setTab("all")
+  }

  let fileFilter: HTMLInputElement | undefined
  let tabList: HTMLDivElement | undefined
  const temporaryTab = tabs().preview
+  const previewTab = (value: string) => {
+    const next = normalizeTab(value)
+    tabs().previewTab(next)
+    const path = file.pathFromTab(next)
+    if (path) void file.load(path)
+    openReviewPanel()
+    queueMicrotask(() => tabs().setActive(next))
+  }
  const openFileBrowser = () => {
-    controller.browser.open()
+    previewTab(SESSION_OPEN_FILE_TAB)
    queueMicrotask(() => fileFilter?.focus())
  }
+  const activateTab = (value: string) => {
+    const next = normalizeTab(value)
+    const path = file.pathFromTab(next)
+    if (path) void file.load(path)
+    openReviewPanel()
+    tabs().setActive(next)
+  }
+  const browserTab = createMemo(() => {
+    if (!props.fileBrowserState) return undefined
+    const active = activeTab()
+    if (active === SESSION_OPEN_FILE_TAB) return SESSION_OPEN_FILE_TAB
+    if (active && file.pathFromTab(active)) return active
+    return activeFileTab()
+  })
+  // Keep the file-browser shell mounted while any file tab exists. Kobalte briefly
+  // selects Review while the tab For replaces a preview trigger, which would
+  // otherwise dispose the sidebar and reset scroll.
+  const fileBrowserMounted = createMemo(() => {
+    if (!props.fileBrowserState) return false
+    return openedTabs().length > 0 || openFileOpen() || !!browserTab()
+  })
+  const fileBrowserVisible = createMemo(() => {
+    const active = activeTab()
+    return active !== "review" && active !== "context" && active !== "empty"
+  })
  const openFileKeybind = createMemo(() => command.keybindParts("file.open"))
  const closeTabKeybind = createMemo(() => command.keybindParts("tab.close"))
  const [store, setStore] = createStore({
@@ -216,6 +264,27 @@ export function SessionSidePanel(props: {
    setStore("activeDraggable", undefined)
  }

+  createEffect(() => {
+    if (!file.ready()) return
+
+    setSessionHandoff(sessionKey(), {
+      files: tabs()
+        .all()
+        .reduce<Record<string, SelectedLineRange | null>>((acc, tab) => {
+          const path = file.pathFromTab(tab)
+          if (!path) return acc
+
+          const selected = file.selectedLines(path)
+          acc[path] =
+            selected && typeof selected === "object" && "start" in selected && "end" in selected
+              ? (selected as SelectedLineRange)
+              : null
+
+          return acc
+        }, {}),
+    })
+  })
+
  return (
    <Show when={isDesktop() && !(settings.general.newLayoutDesigns() && !params.id)}>
      <aside
@@ -382,7 +451,9 @@ export function SessionSidePanel(props: {
                                    iconSize="large"
                                    class="!rounded-md"
                                    onClick={() => {
-                                      void controller.dialog.openFile()
+                                      void import("@/components/dialog-select-file").then((x) => {
+                                        dialog.show(() => <x.DialogSelectFile mode="files" onOpenFile={showAllFiles} />)
+                                      })
                                    }}
                                    aria-label={language.t("command.file.open")}
                                  />
@@ -26,7 +26,6 @@ function setup(
        return new Response(undefined, { status: 204 })
      if (request.method === "POST" && request.url.endsWith("/prompt")) {
        return Response.json({
-          admittedSeq: 1,
          id: "msg_1",
          sessionID: "ses_1",
          timeCreated: 1,
@@ -229,7 +229,6 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
          ],
        })
        return {
-          admittedSeq: 0,
          id: value.id ?? "",
          sessionID: value.sessionID,
          timeCreated: Date.now(),
@@ -255,7 +254,6 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
          })),
        })
        return {
-          admittedSeq: 0,
          id: value.id ?? "",
          sessionID: value.sessionID,
          timeCreated: Date.now(),
@@ -280,7 +278,6 @@ function createV1Api(input: CompatibleInput): CompatibleApi {
          modelID: value.model.modelID,
        })
        return {
-          admittedSeq: 0,
          id: value.id ?? "",
          sessionID: value.sessionID,
          timeCreated: Date.now(),
@@ -244,7 +244,10 @@ export function make(input: { readonly client: OpenCodeClient; readonly connecti
      return {}
    },
    forkSession: async (params) => {
-      const forked = await input.client.session.fork({ sessionID: params.sessionId })
+      const forked = await input.client.session.fork({
+        sessionID: params.sessionId,
+        boundary: { type: "through" },
+      })
      const state = await attach(forked, forked.location.directory, params.mcpServers ?? [])
      await replay(state)
      return { sessionId: state.id, configOptions: configOptions(state) }
@@ -105,7 +105,7 @@ async function selectSession(input: {
    return {
      session: input.fork
        ? await input.client.session
-            .fork({ sessionID: explicit.id }, ...requestOptions(input.signal))
+            .fork({ sessionID: explicit.id, boundary: { type: "through" } }, ...requestOptions(input.signal))
            .catch((error) => {
              throw new SessionTargetMutationError(error)
            })
@@ -118,9 +118,11 @@ async function selectSession(input: {
  if (!selected) return { session: undefined, location }
  return {
    session: input.fork
-      ? await input.client.session.fork({ sessionID: selected.id }, ...requestOptions(input.signal)).catch((error) => {
-          throw new SessionTargetMutationError(error)
-        })
+      ? await input.client.session
+          .fork({ sessionID: selected.id, boundary: { type: "through" } }, ...requestOptions(input.signal))
+          .catch((error) => {
+            throw new SessionTargetMutationError(error)
+          })
      : selected,
  }
 }
@@ -267,7 +267,7 @@ async function run(input: {
    values.push(...input.turn(messageID))
    wake?.()
    wake = undefined
-    return ok({ admittedSeq: 1, id: messageID, sessionID: "ses_1", timeCreated: 1 }) as never
+    return ok({ id: messageID, sessionID: "ses_1", timeCreated: 1 }) as never
  })
  await runNonInteractivePrompt({
    client: sdk,
@@ -136,7 +136,7 @@ export type Endpoint5_4Input = { readonly sessionID: Session.ID }
 export type Endpoint5_4Output = void
 export type SessionRemoveOperation<E = never> = (input: Endpoint5_4Input) => Effect.Effect<Endpoint5_4Output, E>

-export type Endpoint5_5Input = { readonly sessionID: Session.ID; readonly messageID?: SessionMessage.ID | undefined }
+export type Endpoint5_5Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
 export type Endpoint5_5Output = Session.Info
 export type SessionForkOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>

@@ -342,8 +342,10 @@ export type Endpoint5_26Output =
          readonly data: {
            readonly sessionID: Session.ID
            readonly parentID: Session.ID
-            readonly parentSeq: number
-            readonly from?: SessionMessage.ID | undefined
+            readonly boundary: Session.ForkBoundary
+            readonly instructions?:
+              | { readonly [x: string & Brand.Brand<"Instruction.Key">]: string & Brand.Brand<"Instruction.Hash"> }
+              | undefined
          }
        }
      | {
@@ -329,7 +329,7 @@ const Endpoint5_4 = (raw: RawClient["server.session"]) => (input: Endpoint5_4Inp

 const Endpoint5_5 = (raw: RawClient["server.session"]) => (input: Endpoint5_5Input) =>
  preserveEffect<Endpoint5_5Output>()(
-    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { messageID: input["messageID"] } }).pipe(
+    raw["session.fork"]({ params: { sessionID: input["sessionID"] }, payload: { boundary: input["boundary"] } }).pipe(
      Effect.mapError(mapClientError),
      Effect.map((value) => value.data),
    ),
@@ -510,7 +510,7 @@ export function make(options: ClientOptions) {
          {
            method: "POST",
            path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
-            body: { messageID: input["messageID"] },
+            body: { boundary: input["boundary"] },
            successStatus: 200,
            declaredStatuses: [404, 400, 401],
            empty: false,
@@ -14,6 +14,8 @@ export type PermissionEffect = "allow" | "deny" | "ask"

 export type PluginInfo = { id: string }

+export type SessionForkBoundary = { type: "before"; messageID: string } | { type: "through"; messageID: string }
+
 export type MoneyUSD = number

 export type TokenUsageInfo = {
@@ -43,13 +45,7 @@ export type PromptMention = { start: number; end: number; text: string }

 export type SessionPendingSyntheticData = { text: string; description?: string; metadata?: { [x: string]: JsonValue } }

-export type SessionPendingCompaction = {
-  admittedSeq: number
-  id: string
-  sessionID: string
-  timeCreated: number
-  type: "compaction"
-}
+export type SessionPendingCompaction = { id: string; sessionID: string; timeCreated: number; type: "compaction" }

 export type SessionMessageAgentSelected = {
  id: string
@@ -628,7 +624,7 @@ export type SessionForked = {
  type: "session.forked"
  durable: { aggregateID: string; seq: number; version: 2 }
  location?: LocationRef
-  data: { sessionID: string; parentID: string; parentSeq: number; from?: string }
+  data: { sessionID: string; parentID: string; boundary: SessionForkBoundary; instructions?: { [x: string]: string } }
 }

 export type SessionInputPromoted = {
@@ -1210,7 +1206,6 @@ export type PromptFileAttachment = {
 export type PromptAgentAttachment = { name: string; mention?: PromptMention }

 export type SessionPendingSynthetic = {
-  admittedSeq: number
  id: string
  sessionID: string
  timeCreated: number
@@ -1755,7 +1750,7 @@ export type PermissionRuleset = Array<PermissionRule>
 export type SessionInfo = {
  id: string
  parentID?: string
-  fork?: { sessionID: string; messageID?: string }
+  fork?: { sessionID: string; boundary: SessionForkBoundary }
  projectID: string
  agent?: string
  model?: ModelRef
@@ -1966,7 +1961,6 @@ export type AgentInfo = {
 export type SessionsResponse = { data: Array<SessionInfo>; cursor: { previous?: string | null; next?: string | null } }

 export type SessionPendingUser = {
-  admittedSeq: number
  id: string
  sessionID: string
  timeCreated: number
@@ -2702,7 +2696,9 @@ export type SessionRemoveOutput = void

 export type SessionForkInput = {
  readonly sessionID: { readonly sessionID: string }["sessionID"]
-  readonly messageID?: { readonly messageID?: string | undefined }["messageID"]
+  readonly boundary: {
+    readonly boundary: { readonly type: "before"; readonly messageID: string } | { readonly type: "through" }
+  }["boundary"]
 }

 export type SessionForkOutput = { data: SessionInfo }["data"]
@@ -268,7 +268,6 @@ const session = {

 const admission = {
  data: {
-    admittedSeq: 0,
    id: "msg_test",
    sessionID: "ses_test",
    type: "user",
@@ -281,7 +280,6 @@ const admission = {
 const compactionAdmission = {
  data: {
    type: "compaction",
-    admittedSeq: 1,
    id: "msg_compaction",
    sessionID: "ses_test",
    timeCreated: 1_717_171_717_000,
@@ -304,7 +304,6 @@ test("session.pending.list uses the public HTTP contract", async () => {
  const requests: Array<{ method: string; url: string }> = []
  const pending = [
    {
-      admittedSeq: 3,
      id: "msg_pending",
      sessionID: "ses_test",
      timeCreated: 1_717_171_717_000,
@@ -547,7 +546,6 @@ const session = {

 const admission = {
  data: {
-    admittedSeq: 0,
    id: "msg_test",
    sessionID: "ses_test",
    type: "user",
@@ -559,7 +557,6 @@ const admission = {

 const syntheticAdmission = {
  data: {
-    admittedSeq: 1,
    id: "msg_synthetic",
    sessionID: "ses_test",
    type: "synthetic",
@@ -572,7 +569,6 @@ const syntheticAdmission = {
 const compactionAdmission = {
  data: {
    type: "compaction",
-    admittedSeq: 1,
    id: "msg_compaction",
    sessionID: "ses_test",
    timeCreated: 1_717_171_717_000,
@@ -1,9 +1,9 @@
 {
  "version": "7",
  "dialect": "sqlite",
-  "id": "a4ba73b4-21bc-41ab-a415-94e2ca38d798",
+  "id": "db37a97f-9b5e-4c87-be8b-4feace35136c",
  "prevIds": [
-    "5f0a1db8-d4bf-42c3-becb-96b46fe66bed"
+    "a4ba73b4-21bc-41ab-a415-94e2ca38d798"
  ],
  "ddl": [
    {
@@ -1266,17 +1266,7 @@
      "autoincrement": false,
      "default": null,
      "generated": null,
-      "name": "fork_message_id",
-      "entityType": "columns",
-      "table": "session"
-    },
-    {
-      "type": "integer",
-      "notNull": false,
-      "autoincrement": false,
-      "default": null,
-      "generated": null,
-      "name": "fork_seq",
+      "name": "fork_boundary",
      "entityType": "columns",
      "table": "session"
    },
@@ -393,7 +393,8 @@ export const layer = (options?: Options) => Layer.effect(
        const key = JSON.stringify(target)
        if (watched.has(key)) continue
        watched.add(key)
-        yield* watcher.subscribe(target).pipe(
+        const stream = yield* watcher.subscribe(target)
+        yield* stream.pipe(
          Stream.runForEach((update) => PubSub.publish(updates, update)),
          Effect.forkScoped({ startImmediately: true }),
        )
@@ -57,5 +57,6 @@ export const migrations = (
    import("./migration/20260716020354_kv"),
    import("./migration/20260722011141_delete_tool_progress_events"),
    import("./migration/20260722170000_canonical_tool_results"),
+    import("./migration/20260729022634_session_fork_boundary"),
  ])
 ).map((module) => module.default) satisfies DatabaseMigration.Migration[]
@@ -0,0 +1,13 @@
+import { Effect } from "effect"
+import type { DatabaseMigration } from "../migration"
+
+export default {
+  id: "20260729022634_session_fork_boundary",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session\` ADD \`fork_boundary\` text;`)
+      yield* tx.run(`ALTER TABLE \`session\` DROP COLUMN \`fork_message_id\`;`)
+      yield* tx.run(`ALTER TABLE \`session\` DROP COLUMN \`fork_seq\`;`)
+    })
+  },
+} satisfies DatabaseMigration.Migration
@@ -213,8 +213,7 @@ export default {
          \`workspace_id\` text,
          \`parent_id\` text,
          \`fork_session_id\` text,
-          \`fork_message_id\` text,
-          \`fork_seq\` integer,
+          \`fork_boundary\` text,
          \`slug\` text NOT NULL,
          \`directory\` text NOT NULL,
          \`path\` text,
@@ -47,13 +47,12 @@ const layer = Layer.effect(
      const home = path.resolve(location.directory) === path.resolve(os.homedir())

      if (!home && location.vcs) {
-        yield* watcher
-          .subscribe({
-            path: location.directory,
-            type: "directory",
-            ignore: [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)],
-          })
-          .pipe(Stream.runForEach(publish), Effect.forkScoped)
+        const updates = yield* watcher.subscribe({
+          path: location.directory,
+          type: "directory",
+          ignore: [...Ignore.PATTERNS, ...config, ...protecteds(location.directory)],
+        })
+        yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
      }
      if (home) {
        yield* Effect.logInfo("location watcher skipped home directory", { directory: location.directory })
@@ -68,9 +67,8 @@ const layer = Layer.effect(
          const ignore = (yield* fs.readDirectoryEntries(vcs).pipe(Effect.catch(() => Effect.succeed([])))).flatMap(
            (entry) => (entry.name === "HEAD" ? [] : [entry.name]),
          )
-          yield* watcher
-            .subscribe({ path: vcs, type: "directory", ignore })
-            .pipe(Stream.runForEach(publish), Effect.forkScoped)
+          const updates = yield* watcher.subscribe({ path: vcs, type: "directory", ignore })
+          yield* updates.pipe(Stream.runForEach(publish), Effect.forkScoped)
        }
      }
    }).pipe(
@@ -59,7 +59,7 @@ export interface NativeInterface {
 export class Native extends Context.Service<Native, NativeInterface>()("@opencode/Watcher/Native") {}

 export interface Interface {
-  readonly subscribe: (input: WatchInput) => Stream.Stream<Update>
+  readonly subscribe: (input: WatchInput) => Effect.Effect<Stream.Stream<Update>>
 }

 export const Options = Schema.Struct({
@@ -83,7 +83,7 @@ export const layer = (options?: Options) =>
    Service,
    Effect.gen(function* () {
      if (options?.enabled === false) {
-        return Service.of({ subscribe: () => Stream.empty })
+        return Service.of({ subscribe: () => Effect.succeed(Stream.empty) })
      }
      const native = yield* Native

@@ -131,11 +131,19 @@ export const layer = (options?: Options) =>
      const subscribe = (input: WatchInput) => {
        const target = path.resolve(input.path)
        const ignore = [...new Set(input.type === "directory" ? (input.ignore ?? []) : [])].toSorted()
-        return Stream.unwrap(
-          RcMap.get(watchers, { type: input.type, target, ignore }).pipe(
-            Effect.map((pubsub) => Stream.fromPubSub(pubsub)),
-          ),
-        )
+        return Effect.gen(function* () {
+          yield* Effect.logInfo("watcher subscribe", {
+            path: target,
+            type: input.type,
+            ignores: ignore.length,
+          })
+          return Stream.unwrap(
+            Effect.gen(function* () {
+              const pubsub = yield* RcMap.get(watchers, { type: input.type, target, ignore })
+              return Stream.fromPubSub(pubsub)
+            }),
+          )
+        })
      }

      return Service.of({ subscribe })
@@ -253,7 +253,8 @@ const layer = Layer.effect(
        // inside), so don't watch what can't trigger anything.
        if (yield* fs.isDir(operation.target)) continue
        watched.add(operation.target)
-        yield* watcher.subscribe({ path: operation.target, type: "file" }).pipe(
+        const updates = yield* watcher.subscribe({ path: operation.target, type: "file" })
+        yield* updates.pipe(
          Stream.runForEach(() => PubSub.publish(configuredChanges, undefined)),
          Effect.catchCause((cause) =>
            Effect.logError("configured plugin watch failed", { target: operation.target, cause }),
@@ -28,11 +28,12 @@ import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
 import { SessionStore } from "./session/store"
 import { SessionExecution } from "./session/execution"
-import { MessageDecodeError, NotFoundError } from "./session/error"
+import { ForkEmptyError, MessageDecodeError, NotFoundError } from "./session/error"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { LocationServiceMap } from "./location-service-map"
 import { SessionEvent } from "./session/event"
 import { SessionPending } from "./session/pending"
+import { InstructionState } from "./session/instruction-state"
 import { SessionGenerate } from "./session/generate"
 import { Snapshot } from "./snapshot"
 import { SessionRevert } from "./session/revert"
@@ -106,7 +107,7 @@ type CompactInput = {

 type ForkInput = {
  sessionID: SessionSchema.ID
-  messageID?: SessionMessage.ID
+  boundary: Session.ForkRequestBoundary
 }

 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
@@ -181,7 +182,9 @@ export interface Interface {
    readonly data: SessionSchema.Info[]
  }>
  readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info, NotFoundError>
-  readonly fork: (input: ForkInput) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError>
+  readonly fork: (
+    input: ForkInput,
+  ) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>
  readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>
  readonly remove: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>
  readonly messages: (input: {
@@ -395,25 +398,33 @@ const layer = Layer.effect(
      }),
      fork: Effect.fn("Session.fork")(function* (input) {
        const parent = yield* result.get(input.sessionID)
-        const boundary = input.messageID
-          ? yield* db
-              .select({ seq: SessionMessageTable.seq })
-              .from(SessionMessageTable)
-              .where(
-                and(eq(SessionMessageTable.session_id, input.sessionID), eq(SessionMessageTable.id, input.messageID)),
-              )
-              .get()
-              .pipe(Effect.orDie)
-          : undefined
-        if (input.messageID && !boundary)
-          return yield* new MessageNotFoundError({ sessionID: input.sessionID, messageID: input.messageID })
+        const boundary = yield* db
+          .select({ id: SessionMessageTable.id, seq: SessionMessageTable.seq })
+          .from(SessionMessageTable)
+          .where(
+            and(
+              eq(SessionMessageTable.session_id, input.sessionID),
+              input.boundary.type === "before" ? eq(SessionMessageTable.id, input.boundary.messageID) : undefined,
+            ),
+          )
+          .orderBy(desc(SessionMessageTable.seq))
+          .limit(1)
+          .get()
+          .pipe(Effect.orDie)
+        if (!boundary && input.boundary.type === "before")
+          return yield* new MessageNotFoundError({
+            sessionID: input.sessionID,
+            messageID: input.boundary.messageID,
+          })
+        if (!boundary) return yield* new ForkEmptyError({ sessionID: input.sessionID })
        const sessionID = SessionSchema.ID.create()
-        const parentSeq = boundary ? boundary.seq - 1 : yield* Bus.latestSequence(db, parent.id)
+        const instructionThrough =
+          input.boundary.type === "before" ? boundary.seq - 1 : yield* Bus.latestSequence(db, parent.id)
        yield* bus.publish(SessionEvent.Forked, {
          sessionID,
          parentID: parent.id,
-          parentSeq,
-          from: input.messageID,
+          boundary: { ...input.boundary, messageID: boundary.id },
+          instructions: yield* InstructionState.valuesAt(db, parent.id, instructionThrough),
        })
        return yield* result.get(sessionID).pipe(Effect.orDie)
      }),
@@ -10,6 +10,14 @@ export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Ses
  sessionID: SessionSchema.ID,
 }) {}

+export class ForkEmptyError extends Schema.TaggedErrorClass<ForkEmptyError>()("Session.ForkEmptyError", {
+  sessionID: SessionSchema.ID,
+}) {
+  override get message() {
+    return `Cannot fork empty session: ${this.sessionID}`
+  }
+}
+
 export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
  sessionID: SessionSchema.ID,
  messageID: SessionMessage.ID,
@@ -8,7 +8,6 @@ import { AbsolutePath, RelativePath } from "../schema"
 import { Workspace } from "../workspace"
 import { SessionSchema } from "./schema"
 import { SessionTable } from "./sql"
-import { SessionMessage } from "./message"
 import { PersistedRevert } from "@opencode-ai/schema/session-revert"
 import { Money } from "@opencode-ai/schema/money"

@@ -20,12 +19,13 @@ export function fromRow(row: typeof SessionTable.$inferSelect): SessionSchema.In
    projectID: Project.ID.make(row.project_id),
    title: row.title,
    parentID: row.parent_id ? SessionSchema.ID.make(row.parent_id) : undefined,
-    fork: row.fork_session_id
-      ? {
-          sessionID: SessionSchema.ID.make(row.fork_session_id),
-          messageID: row.fork_message_id ? SessionMessage.ID.make(row.fork_message_id) : undefined,
-        }
-      : undefined,
+    fork:
+      row.fork_session_id && row.fork_boundary
+        ? {
+            sessionID: SessionSchema.ID.make(row.fork_session_id),
+            boundary: row.fork_boundary,
+          }
+        : undefined,
    agent: row.agent ? Agent.ID.make(row.agent) : undefined,
    model: row.model
      ? {
@@ -10,11 +10,12 @@ import { SessionEvent } from "./event"
 import { SessionMessage } from "./message"
 import { Event } from "@opencode-ai/schema/event"
 import { SessionSchema } from "./schema"
-import { InstructionBlobTable, InstructionStateTable, SessionTable } from "./sql"
+import { InstructionBlobTable, InstructionStateTable } from "./sql"

 type DatabaseService = Database.Interface["db"]

 const decodeInstructionsUpdated = Schema.decodeUnknownSync(SessionEvent.InstructionsUpdated.data)
+const decodeForked = Schema.decodeUnknownSync(SessionEvent.Forked.data)

 export interface Observation extends Instructions.Admission {
  readonly sessionID: SessionSchema.ID
@@ -94,6 +95,26 @@ export const apply = Effect.fn("InstructionState.apply")(function* (
    .pipe(Effect.orDie)
 })

+export const initialize = Effect.fn("InstructionState.initialize")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  seq: number,
+  values: Instructions.Values,
+) {
+  yield* db
+    .insert(InstructionStateTable)
+    .values({
+      session_id: sessionID,
+      epoch_start: seq,
+      through_seq: seq,
+      initial_values: values,
+      current_values: values,
+    })
+    .onConflictDoNothing()
+    .run()
+    .pipe(Effect.orDie)
+})
+
 export const advanceEpoch = Effect.fn("InstructionState.advanceEpoch")(function* (
  db: DatabaseService,
  sessionID: SessionSchema.ID,
@@ -255,6 +276,14 @@ const stateFromEvents = Effect.fnUntraced(function* (db: DatabaseService, sessio
  return folded ? foldedState(sessionID, folded) : undefined
 })

+export const valuesAt = Effect.fn("InstructionState.valuesAt")(function* (
+  db: DatabaseService,
+  sessionID: SessionSchema.ID,
+  through: number,
+) {
+  return fold(yield* instructionEvents(db, sessionID, through))?.current
+})
+
 const latestRelevantSequence = Effect.fnUntraced(function* (db: DatabaseService, sessionID: SessionSchema.ID) {
  return yield* db
    .select({ seq: EventTable.seq })
@@ -324,15 +353,23 @@ const revertedEventType = Bus.versionedType(
  SessionEvent.RevertEvent.Committed.type,
  SessionEvent.RevertEvent.Committed.durable.version,
 )
-const relevantEventTypes = [instructionEventType, compactionEventType, movedEventType, revertedEventType]
+const forkedEventType = Bus.versionedType(SessionEvent.Forked.type, SessionEvent.Forked.durable.version)
+const relevantEventTypes = [
+  forkedEventType,
+  instructionEventType,
+  compactionEventType,
+  movedEventType,
+  revertedEventType,
+]

 type InstructionEventRow = typeof EventTable.$inferSelect

 const instructionEvents = Effect.fnUntraced(function* (
  db: DatabaseService,
  sessionID: SessionSchema.ID,
+  through?: number,
 ): Effect.fn.Return<ReadonlyArray<InstructionEventRow>> {
-  return yield* eventRows(db, sessionID, relevantEventTypes)
+  return yield* eventRows(db, sessionID, relevantEventTypes, undefined, through)
 })

 const instructionUpdatesAfter = Effect.fnUntraced(function* (
@@ -348,48 +385,22 @@ const eventRows = Effect.fnUntraced(function* (
  sessionID: SessionSchema.ID,
  types: ReadonlyArray<string>,
  after?: number,
-): Effect.fn.Return<ReadonlyArray<InstructionEventRow>> {
-  const segments = (yield* lineage(db, sessionID)).filter(
-    (segment) => after === undefined || segment.through === undefined || segment.through > after,
-  )
-  return (yield* Effect.forEach(segments, (segment) =>
-    db
-      .select()
-      .from(EventTable)
-      .where(
-        and(
-          eq(EventTable.aggregate_id, segment.sessionID),
-          inArray(EventTable.type, types),
-          segment.through === undefined ? undefined : lte(EventTable.seq, segment.through),
-          after === undefined ? undefined : gt(EventTable.seq, after),
-        ),
-      )
-      .orderBy(asc(EventTable.seq))
-      .all()
-      .pipe(Effect.orDie),
-  )).flat()
-})
-
-const lineage = Effect.fnUntraced(function* (
-  db: DatabaseService,
-  sessionID: SessionSchema.ID,
  through?: number,
-): Effect.fn.Return<ReadonlyArray<{ readonly sessionID: SessionSchema.ID; readonly through?: number }>> {
-  const session = yield* db
-    .select({ parentID: SessionTable.fork_session_id, forkSeq: SessionTable.fork_seq })
-    .from(SessionTable)
-    .where(eq(SessionTable.id, sessionID))
-    .get()
+): Effect.fn.Return<ReadonlyArray<InstructionEventRow>> {
+  return yield* db
+    .select()
+    .from(EventTable)
+    .where(
+      and(
+        eq(EventTable.aggregate_id, sessionID),
+        inArray(EventTable.type, types),
+        after === undefined ? undefined : gt(EventTable.seq, after),
+        through === undefined ? undefined : lte(EventTable.seq, through),
+      ),
+    )
+    .orderBy(asc(EventTable.seq))
+    .all()
    .pipe(Effect.orDie)
-  const inherited =
-    session?.parentID && session.forkSeq !== null
-      ? yield* lineage(
-          db,
-          session.parentID,
-          through === undefined ? session.forkSeq : Math.min(session.forkSeq, through),
-        )
-      : []
-  return [...inherited, { sessionID, ...(through === undefined ? {} : { through }) }]
 })

 function fold(rows: ReadonlyArray<InstructionEventRow>) {
@@ -402,6 +413,12 @@ function fold(rows: ReadonlyArray<InstructionEventRow>) {
      }
    | undefined
  >((state, row) => {
+    if (row.type === forkedEventType) {
+      const instructions = decodeForked(row.data).instructions
+      return instructions
+        ? { epochStart: row.seq, throughSeq: row.seq, initial: instructions, current: instructions }
+        : undefined
+    }
    if (row.type === movedEventType || row.type === revertedEventType) return undefined
    if (row.type === compactionEventType)
      return state
@@ -53,7 +53,6 @@ export class LifecycleConflict extends Schema.TaggedErrorClass<LifecycleConflict

 const fromRow = (row: typeof SessionPendingTable.$inferSelect): Info => {
  const base = {
-    admittedSeq: row.admitted_seq,
    id: SessionMessage.ID.make(row.id),
    sessionID: SessionSchema.ID.make(row.session_id),
    timeCreated: DateTime.makeUnsafe(row.time_created),
@@ -134,7 +133,6 @@ const promotedFromHistory = Effect.fn("SessionPending.promotedFromHistory")(func
    const decoded = decodeAdmittedEvent(row.data)
    if (decoded._tag !== "Some" || decoded.value.inputID !== id) continue
    const base = {
-      admittedSeq: row.seq,
      id,
      sessionID,
      timeCreated: DateTime.makeUnsafe(row.created),
@@ -172,10 +170,7 @@ export const admit = Effect.fn("SessionPending.admit")(function* (
    })
    .pipe(
      Effect.flatMap((event) => {
-        if (event.durable === undefined)
-          return Effect.die(new Error("Session input admission event is missing aggregate sequence"))
        const base = {
-          admittedSeq: event.durable.seq,
          id: request.id,
          sessionID: request.sessionID,
          timeCreated: event.created,
@@ -1,6 +1,6 @@
 export * as SessionProjector from "./projector"

-import { and, asc, desc, eq, gt, gte, inArray, lt, sql } from "drizzle-orm"
+import { and, asc, desc, eq, gt, gte, inArray, lt, lte, sql } from "drizzle-orm"
 import { DateTime, Effect, Layer, Schema, Stream } from "effect"
 import { Database } from "../database/database"
 import { Bus } from "../bus"
@@ -174,25 +174,28 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
    .get()
    .pipe(Effect.orDie)
  if (!parent) return yield* Effect.die(new Error(`Fork parent session not found: ${event.data.parentID}`))
-  const boundary = event.data.from
-    ? yield* db
-        .select({ seq: SessionMessageTable.seq })
-        .from(SessionMessageTable)
-        .where(
-          and(eq(SessionMessageTable.session_id, event.data.parentID), eq(SessionMessageTable.id, event.data.from)),
-        )
-        .get()
-        .pipe(Effect.orDie)
-    : undefined
-  if (event.data.from && !boundary)
-    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.from}`))
+  const boundary = yield* db
+    .select({ seq: SessionMessageTable.seq })
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, event.data.parentID),
+        eq(SessionMessageTable.id, event.data.boundary.messageID),
+      ),
+    )
+    .get()
+    .pipe(Effect.orDie)
+  if (!boundary)
+    return yield* Effect.die(new Error(`Fork boundary message not found: ${event.data.boundary.messageID}`))
  const copied = yield* db
    .select({ seq: SessionMessageTable.seq })
    .from(SessionMessageTable)
    .where(
      and(
        eq(SessionMessageTable.session_id, event.data.parentID),
-        boundary === undefined ? undefined : lt(SessionMessageTable.seq, boundary.seq),
+        event.data.boundary.type === "before"
+          ? lt(SessionMessageTable.seq, boundary.seq)
+          : lte(SessionMessageTable.seq, boundary.seq),
      ),
    )
    .orderBy(desc(SessionMessageTable.seq))
@@ -207,8 +210,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
      id: event.data.sessionID,
      parent_id: null,
      fork_session_id: event.data.parentID,
-      fork_message_id: event.data.from,
-      fork_seq: event.data.parentSeq,
+      fork_boundary: event.data.boundary,
      project_id: parent.project_id,
      workspace_id: parent.workspace_id,
      slug: Slug.create(),
@@ -314,8 +316,9 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (

    cursor = rows.at(-1)!.seq
  }
-  yield* Bus.reserveSequence(db, event.data.sessionID, event.data.parentSeq)
-  yield* InstructionState.rebuild(db, event.data.sessionID)
+  if (copiedSeq !== undefined) yield* Bus.reserveSequence(db, event.data.sessionID, copiedSeq)
+  if (event.data.instructions)
+    yield* InstructionState.initialize(db, event.data.sessionID, event.durable.seq, event.data.instructions)
 })

 function run(db: DatabaseService, event: MessageEvent) {
@@ -32,8 +32,7 @@ export const SessionTable = sqliteTable(
    workspace_id: text().$type<Workspace.ID>(),
    parent_id: text().$type<SessionSchema.ID>(),
    fork_session_id: text().$type<SessionSchema.ID>(),
-    fork_message_id: text().$type<SessionMessage.ID>(),
-    fork_seq: integer(),
+    fork_boundary: text({ mode: "json" }).$type<Session.ForkBoundary>(),
    slug: text().notNull(),
    directory: directoryColumn().notNull(),
    path: pathColumn(),
@@ -1,9 +1,10 @@
-import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider"
+import type { LanguageModelV3, LanguageModelV3StreamPart } from "@ai-sdk/provider"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { Model } from "@opencode-ai/core/model"
 import { Provider } from "@opencode-ai/core/provider"
 import { LLM, LLMError, LLMEvent, Message } from "@opencode-ai/ai"
 import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route"
+import { compileRequest } from "@opencode-ai/ai/route/client"
 import { expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { testEffect } from "./lib/effect"
@@ -87,9 +88,7 @@ it.effect("projects request settings, headers, and body overlays", () =>
      headers: { "x-test": "header" },
      body: { safety_setting: "strict" },
    })
-    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: resolved, prompt: "Hello" }),
-    )
+    const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))

    expect(prepared.body.providerOptions).toEqual({
      google: { thinkingConfig: { thinkingBudget: 1024 } },
@@ -112,9 +111,7 @@ it.effect("maps pro reasoning bodies to AI SDK provider options", () =>
      ...model("@ai-sdk/openai"),
      body: { reasoning: { mode: "pro" } },
    })
-    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: resolved, prompt: "Hello" }),
-    )
+    const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))

    expect(body).toBeUndefined()
    expect(prepared.body.providerOptions).toEqual({
@@ -139,9 +136,7 @@ it.effect("maps package-specific AI SDK provider option keys", () =>
    ] as const
    for (const [packageName, key, settings] of cases) {
      const resolved = yield* aisdk.model(model(packageName, { reasoningEffort: "high" }))
-      const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-        LLM.request({ model: resolved, prompt: "Hello" }),
-      )
+      const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))
      expect(prepared.body.providerOptions).toEqual({ [key]: settings })
    }
  }),
@@ -155,17 +150,13 @@ it.effect("forces reasoning and projects both Azure AI SDK namespaces", () =>
    })

    const openai = yield* aisdk.model(model("@ai-sdk/openai", { reasoningEffort: "high" }))
-    const openaiPrepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: openai, prompt: "Hello" }),
-    )
+    const openaiPrepared = yield* compileRequest(LLM.request({ model: openai, prompt: "Hello" }))
    expect(openaiPrepared.body.providerOptions).toEqual({
      openai: { reasoningEffort: "high", forceReasoning: true },
    })

    const azure = yield* aisdk.model(model("@ai-sdk/azure", { reasoningEffort: "high" }))
-    const azurePrepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: azure, prompt: "Hello" }),
-    )
+    const azurePrepared = yield* compileRequest(LLM.request({ model: azure, prompt: "Hello" }))
    expect(azurePrepared.body.providerOptions).toEqual({
      openai: { reasoningEffort: "high", forceReasoning: true },
      azure: { reasoningEffort: "high", forceReasoning: true },
@@ -187,9 +178,7 @@ it.effect("routes AI Gateway model options by upstream prefix", () =>
      }),
      modelID: Model.ID.make("anthropic/claude-sonnet-5"),
    })
-    const anthropicPrepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: anthropic, prompt: "Hello" }),
-    )
+    const anthropicPrepared = yield* compileRequest(LLM.request({ model: anthropic, prompt: "Hello" }))
    expect(anthropicPrepared.body.providerOptions).toEqual({
      gateway: { order: ["anthropic"] },
      anthropic: { thinking: { type: "adaptive" } },
@@ -199,9 +188,7 @@ it.effect("routes AI Gateway model options by upstream prefix", () =>
      ...model("@ai-sdk/gateway", { reasoningConfig: { type: "enabled" } }),
      modelID: Model.ID.make("amazon/nova-2-lite"),
    })
-    const bedrockPrepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: bedrock, prompt: "Hello" }),
-    )
+    const bedrockPrepared = yield* compileRequest(LLM.request({ model: bedrock, prompt: "Hello" }))
    expect(bedrockPrepared.body.providerOptions).toEqual({
      bedrock: { reasoningConfig: { type: "enabled" } },
    })
@@ -210,9 +197,7 @@ it.effect("routes AI Gateway model options by upstream prefix", () =>
      ...model("@ai-sdk/gateway", { reasoningEffort: "high" }),
      modelID: Model.ID.make("deepseek/deepseek-v4"),
    })
-    const fallbackPrepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
-      LLM.request({ model: fallback, prompt: "Hello" }),
-    )
+    const fallbackPrepared = yield* compileRequest(LLM.request({ model: fallback, prompt: "Hello" }))
    expect(fallbackPrepared.body.providerOptions).toEqual({
      deepseek: { reasoningEffort: "high" },
    })
@@ -228,7 +213,7 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>

    const resolved = yield* aisdk.model(model("@ai-sdk/anthropic"))
    expect(resolved.route.providerMetadataKey).toBe("anthropic")
-    const prepared = yield* LLMClient.prepare<LanguageModelV3CallOptions>(
+    const prepared = yield* compileRequest(
      LLM.request({
        model: resolved,
        messages: [
@@ -30,9 +30,12 @@ describe("Watcher.testLayer", () => {
    Effect.gen(function* () {
      const watcher = yield* Watcher.Service
      const test = yield* Watcher.Test
-      const received = yield* watcher
-        .subscribe({ path: "/root", type: "directory" })
-        .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped({ startImmediately: true }))
+      const updates = yield* watcher.subscribe({ path: "/root", type: "directory" })
+      const received = yield* updates.pipe(
+        Stream.take(1),
+        Stream.runCollect,
+        Effect.forkScoped({ startImmediately: true }),
+      )
      yield* Effect.yieldNow

      yield* test.emit({ type: "update", path: "/root/file.md" })
@@ -72,9 +75,10 @@ describe("Watcher lifecycle", () => {
      const interrupted = yield* Deferred.make<void>()
      yield* Effect.gen(function* () {
        const watcher = yield* Watcher.Service
-        const consumer = yield* watcher
-          .subscribe({ path: "/pending", type: "directory" })
-          .pipe(Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
+        const consumer = yield* watcher.subscribe({ path: "/pending", type: "directory" }).pipe(
+          Effect.flatMap(Stream.runDrain),
+          Effect.forkScoped({ startImmediately: true }),
+        )
        yield* Deferred.await(started)
        yield* Fiber.interrupt(consumer)
        expect(yield* Deferred.isDone(interrupted)).toBe(true)
@@ -95,9 +99,10 @@ describe("Watcher lifecycle", () => {
    return Effect.gen(function* () {
      const watcher = yield* Watcher.Service
      const consume = () =>
-        watcher
-          .subscribe({ path: "/shared", type: "directory" })
-          .pipe(Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
+        watcher.subscribe({ path: "/shared", type: "directory" }).pipe(
+          Effect.flatMap(Stream.runDrain),
+          Effect.forkScoped({ startImmediately: true }),
+        )
      const first = yield* consume()
      const second = yield* consume()
      yield* Effect.yieldNow
@@ -117,9 +122,8 @@ describe("Watcher lifecycle", () => {
    return Effect.gen(function* () {
      const consumer = yield* Effect.gen(function* () {
        const watcher = yield* Watcher.Service
-        const consumer = yield* watcher
-          .subscribe({ path: "/active", type: "directory" })
-          .pipe(Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
+        const updates = yield* watcher.subscribe({ path: "/active", type: "directory" })
+        const consumer = yield* updates.pipe(Stream.runDrain, Effect.forkScoped({ startImmediately: true }))
        yield* Effect.yieldNow
        expect(counts.subscribes).toBe(1)
        expect(counts.unsubscribes).toBe(0)
@@ -250,9 +254,12 @@ describeWatcher("LocationWatcher", () => {
        const watcher = yield* Watcher.Service
        const target = path.join(directory, "opencode.json")
        const sibling = path.join(directory, "other.json")
-        const update = yield* watcher
-          .subscribe({ path: target, type: "file" })
-          .pipe(Stream.take(1), Stream.runHead, Effect.forkScoped({ startImmediately: true }))
+        const updates = yield* watcher.subscribe({ path: target, type: "file" })
+        const update = yield* updates.pipe(
+          Stream.take(1),
+          Stream.runHead,
+          Effect.forkScoped({ startImmediately: true }),
+        )
        yield* fs.writeFileString(sibling, "sibling")
        const writes = yield* Effect.suspend(() => fs.writeFileString(target, `target-${Math.random()}`)).pipe(
          Effect.repeat(Schedule.spaced("10 millis")),
@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { LLM, Model } from "@opencode-ai/ai"
-import { LLMClient } from "@opencode-ai/ai/route"
+import { compileRequest } from "@opencode-ai/ai/route/client"
 import { Effect } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Credential } from "@opencode-ai/core/credential"
@@ -69,7 +69,7 @@ describe("ModelResolver", () => {
          settings: { apiKey: "secret", baseURL: "https://openai.example/v1" },
        }),
      )
-      const prepared = yield* LLMClient.prepare(LLM.request({ model: resolved, prompt: "Hello" }))
+      const prepared = yield* compileRequest(LLM.request({ model: resolved, prompt: "Hello" }))

      expect(JSON.stringify(prepared.body)).not.toContain("apiKey")
      expect(JSON.stringify(prepared.body)).not.toContain("secret")
@@ -62,7 +62,6 @@ describe("fromPromise", () => {
            seen = value
            return Effect.succeed(
              SessionPending.Synthetic.make({
-                admittedSeq: 1,
                id: SessionMessage.ID.make(input.id),
                sessionID: Session.ID.make(input.sessionID),
                timeCreated: DateTime.makeUnsafe(0),
@@ -41,7 +41,6 @@ const projects = Layer.succeed(
 )
 let requests: LLMRequest[] = []
 const client = Layer.mock(LLMClient.Service)({
-  prepare: () => Effect.die("unused"),
  stream: (request: LLMRequest) => {
    requests.push(request)
    return Stream.make(LLMEvent.textDelta({ id: "summary", text: "manual session summary" }))
@@ -42,7 +42,6 @@ const cost = [
  },
 ]
 const client = Layer.mock(LLMClient.Service)({
-  prepare: () => Effect.die("unused"),
  stream: (request: LLMRequest) => {
    requests.push(request)
    return Stream.make(
@@ -199,7 +199,7 @@ describe("Session.create", () => {
      yield* session.synthetic({ sessionID: parent.id, text: "parent note", resume: false })
      yield* SessionPending.promote(db, bus, parent.id, "steer")

-      const forked = yield* session.fork({ sessionID: parent.id })
+      const forked = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })
      const parentContext = yield* session.context(parent.id)
      const forkContext = yield* session.context(forked.id)
      const history = Array.from(yield* Stream.runCollect(logEvents(session, forked.id)))
@@ -252,6 +252,17 @@ describe("Session.create", () => {
    }),
  )

+  it.effect("rejects forking an empty session", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const parent = yield* session.create({ location })
+
+      expect(
+        yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } }).pipe(Effect.flip),
+      ).toMatchObject({ _tag: "Session.ForkEmptyError", sessionID: parent.id })
+    }),
+  )
+
  it.effect("forks before the selected boundary message", () =>
    Effect.gen(function* () {
      const session = yield* Session.Service
@@ -286,16 +297,27 @@ describe("Session.create", () => {
        tokens: { input: 6, output: 3, reasoning: 1, cache: { read: 2, write: 1 } },
      })

-      const forked = yield* session.fork({ sessionID: parent.id, messageID: second.id })
-      const beforeFirst = yield* session.fork({ sessionID: parent.id, messageID: first.id })
-      const complete = yield* session.fork({ sessionID: parent.id })
+      const forked = yield* session.fork({
+        sessionID: parent.id,
+        boundary: { type: "before", messageID: second.id },
+      })
+      const beforeFirst = yield* session.fork({
+        sessionID: parent.id,
+        boundary: { type: "before", messageID: first.id },
+      })
+      const complete = yield* session.fork({ sessionID: parent.id, boundary: { type: "through" } })

      const context = yield* session.context(forked.id)
      const history = Array.from(yield* Stream.runCollect(logEvents(session, forked.id)))
-      expect(forked.fork).toEqual({ sessionID: parent.id, messageID: second.id })
+      expect(forked.fork).toEqual({
+        sessionID: parent.id,
+        boundary: { type: "before", messageID: second.id },
+      })
      expect(context).toMatchObject([{ text: "First" }])
      expect(context[0]?.id).not.toBe(first.id)
-      expect(history[0]).toMatchObject({ data: { from: second.id } })
+      expect(history[0]).toMatchObject({
+        data: { boundary: { type: "before", messageID: second.id } },
+      })
      expect(forked).toMatchObject({ cost: 0, tokens: { input: 0, output: 0, reasoning: 0 } })
      expect(yield* session.context(beforeFirst.id)).toEqual([])
      expect(beforeFirst).toMatchObject({ cost: 0, tokens: { input: 0, output: 0, reasoning: 0 } })
@@ -484,7 +506,6 @@ describe("Session.create", () => {
          type: "user",
          data: { text: "Replay lifecycle" },
          delivery: "steer",
-          admittedSeq: 1,
        })
        expect(yield* store.context(created.id)).toEqual([])

@@ -49,7 +49,6 @@ const sessionID = SessionSchema.ID.make("ses_generate_test")

 const model = Model.make({ id: "generate-model", provider: "test", route: OpenAIChat.route })
 const client = Layer.mock(LLMClient.Service)({
-  prepare: () => Effect.die(new Error("unused")),
  stream: () => Stream.die(new Error("unused")),
  generate: (request) =>
    Effect.sync(() => {
@@ -1107,7 +1107,7 @@ describe("SessionRunnerLLM", () => {
      systemBaseline = "Latest context"
      yield* runPrompt(session, "Third")

-      const forked = yield* session.fork({ sessionID, messageID: second.id })
+      const forked = yield* session.fork({ sessionID, boundary: { type: "before", messageID: second.id } })
      expect(
        yield* (yield* Database.Service).db
          .select()
@@ -1115,14 +1115,13 @@ describe("SessionRunnerLLM", () => {
          .where(eq(InstructionStateTable.session_id, forked.id))
          .get(),
      ).toMatchObject({
-        initial_values: { "test/context": Instructions.hash("Initial context") },
+        initial_values: { "test/context": Instructions.hash("Changed context") },
        current_values: { "test/context": Instructions.hash("Changed context") },
      })
      yield* session.prompt({ sessionID: forked.id, text: "Forked", resume: false })
      yield* session.resume(forked.id)

-      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([defaultSystem, "Initial context"])
-      expect(systemTexts(requests.at(-1)!)).toContain("Changed context")
+      expect(requests.at(-1)?.system.map((part) => part.text)).toEqual([defaultSystem, "Changed context"])
      expect(systemTexts(requests.at(-1)!)).toContain("Latest context")

      const { db } = yield* Database.Service
@@ -1151,19 +1150,22 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("caps nested fork instruction ancestry at the selected message", () =>
+  it.effect("keeps nested forks self-contained", () =>
    Effect.gen(function* () {
      const session = yield* setup
      yield* runPrompt(session, "First")
      systemBaseline = "Changed context"
      const second = yield* runPrompt(session, "Second")

-      const child = yield* session.fork({ sessionID, messageID: second.id })
+      const child = yield* session.fork({ sessionID, boundary: { type: "before", messageID: second.id } })
      const inheritedFirst = (yield* session.messages({ sessionID: child.id })).find(
        (message) => message.type === "user" && message.text === "First",
      )
      if (!inheritedFirst) return yield* Effect.die(new Error("Nested fork boundary message not found"))
-      const grandchild = yield* session.fork({ sessionID: child.id, messageID: inheritedFirst.id })
+      const grandchild = yield* session.fork({
+        sessionID: child.id,
+        boundary: { type: "before", messageID: inheritedFirst.id },
+      })

      expect(
        yield* (yield* Database.Service).db
@@ -1172,8 +1174,8 @@ describe("SessionRunnerLLM", () => {
          .where(eq(InstructionStateTable.session_id, grandchild.id))
          .get(),
      ).toMatchObject({
-        initial_values: { "test/context": Instructions.hash("Initial context") },
-        current_values: { "test/context": Instructions.hash("Initial context") },
+        initial_values: { "test/context": Instructions.hash("Changed context") },
+        current_values: { "test/context": Instructions.hash("Changed context") },
      })
      return undefined
    }),
@@ -40,7 +40,6 @@ const cost = [
  },
 ]
 const client = Layer.mock(LLMClient.Service)({
-  prepare: () => Effect.die("unused"),
  stream: (request: LLMRequest) => {
    requests.push(request)
    return Stream.make(
@@ -1145,7 +1145,14 @@
            "content": {
              "application/json": {
                "schema": {
-                  "$ref": "#/components/schemas/InvalidRequestError"
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestError1"
+                    },
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestError"
+                    }
+                  ]
                }
              }
            }
@@ -1181,7 +1188,7 @@
            }
          }
        },
-        "description": "Create a child session by copying projected history from the parent. When messageID is supplied, copy messages before that boundary.",
+        "description": "Create a child session by copying projected history through or before a message boundary.",
        "summary": "Fork session",
        "requestBody": {
          "content": {
@@ -1189,22 +1196,13 @@
              "schema": {
                "type": "object",
                "properties": {
-                  "messageID": {
-                    "anyOf": [
-                      {
-                        "type": "string",
-                        "allOf": [
-                          {
-                            "pattern": "^msg_"
-                          }
-                        ]
-                      },
-                      {
-                        "type": "null"
-                      }
-                    ]
+                  "boundary": {
+                    "$ref": "#/components/schemas/Session.ForkRequestBoundary"
                  }
                },
+                "required": [
+                  "boundary"
+                ],
                "additionalProperties": false
              }
            }
@@ -12223,6 +12221,58 @@
        ],
        "additionalProperties": false
      },
+      "Session.ForkBoundary": {
+        "anyOf": [
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "before"
+                ]
+              },
+              "messageID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^msg_"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "type",
+              "messageID"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "through"
+                ]
+              },
+              "messageID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^msg_"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "type",
+              "messageID"
+            ],
+            "additionalProperties": false
+          }
+        ]
+      },
      "Money.USD": {
        "type": "number"
      },
@@ -12385,17 +12435,13 @@
                  }
                ]
              },
-              "messageID": {
-                "type": "string",
-                "allOf": [
-                  {
-                    "pattern": "^msg_"
-                  }
-                ]
+              "boundary": {
+                "$ref": "#/components/schemas/Session.ForkBoundary"
              }
            },
            "required": [
-              "sessionID"
+              "sessionID",
+              "boundary"
            ],
            "additionalProperties": false
          },
@@ -12595,6 +12641,49 @@
        ],
        "additionalProperties": false
      },
+      "Session.ForkRequestBoundary": {
+        "anyOf": [
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "before"
+                ]
+              },
+              "messageID": {
+                "type": "string",
+                "allOf": [
+                  {
+                    "pattern": "^msg_"
+                  }
+                ]
+              }
+            },
+            "required": [
+              "type",
+              "messageID"
+            ],
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "properties": {
+              "type": {
+                "type": "string",
+                "enum": [
+                  "through"
+                ]
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "additionalProperties": false
+          }
+        ]
+      },
      "MessageNotFoundError": {
        "type": "object",
        "properties": {
@@ -12783,14 +12872,6 @@
      "SessionPending.User": {
        "type": "object",
        "properties": {
-          "admittedSeq": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 0
-              }
-            ]
-          },
          "id": {
            "type": "string",
            "allOf": [
@@ -12828,7 +12909,6 @@
          }
        },
        "required": [
-          "admittedSeq",
          "id",
          "sessionID",
          "timeCreated",
@@ -12957,14 +13037,6 @@
      "SessionPending.Synthetic": {
        "type": "object",
        "properties": {
-          "admittedSeq": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 0
-              }
-            ]
-          },
          "id": {
            "type": "string",
            "allOf": [
@@ -13002,7 +13074,6 @@
          }
        },
        "required": [
-          "admittedSeq",
          "id",
          "sessionID",
          "timeCreated",
@@ -13015,14 +13086,6 @@
      "SessionPending.Compaction": {
        "type": "object",
        "properties": {
-          "admittedSeq": {
-            "type": "integer",
-            "allOf": [
-              {
-                "minimum": 0
-              }
-            ]
-          },
          "id": {
            "type": "string",
            "allOf": [
@@ -13050,7 +13113,6 @@
          }
        },
        "required": [
-          "admittedSeq",
          "id",
          "sessionID",
          "timeCreated",
@@ -13705,7 +13767,14 @@
            "type": "string"
          },
          "name": {
-            "type": "string"
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
          }
        },
        "required": [
@@ -13715,7 +13784,7 @@
        ],
        "additionalProperties": false
      },
-      "LLM.ToolContent": {
+      "Tool.Content": {
        "anyOf": [
          {
            "$ref": "#/components/schemas/Tool.TextContent"
@@ -13741,12 +13810,12 @@
            "type": "array",
            "prefixItems": [
              {
-                "$ref": "#/components/schemas/LLM.ToolContent"
+                "$ref": "#/components/schemas/Tool.Content"
              }
            ],
            "minItems": 1,
            "items": {
-              "$ref": "#/components/schemas/LLM.ToolContent"
+              "$ref": "#/components/schemas/Tool.Content"
            }
          },
          "metadata": {
@@ -13795,12 +13864,12 @@
            "type": "array",
            "prefixItems": [
              {
-                "$ref": "#/components/schemas/LLM.ToolContent"
+                "$ref": "#/components/schemas/Tool.Content"
              }
            ],
            "minItems": 1,
            "items": {
-              "$ref": "#/components/schemas/LLM.ToolContent"
+              "$ref": "#/components/schemas/Tool.Content"
            }
          },
          "metadata": {
@@ -14829,27 +14898,27 @@
                  }
                ]
              },
-              "parentSeq": {
-                "type": "integer",
-                "allOf": [
-                  {
-                    "minimum": -1
-                  }
-                ]
+              "boundary": {
+                "$ref": "#/components/schemas/Session.ForkBoundary"
              },
-              "from": {
-                "type": "string",
-                "allOf": [
-                  {
-                    "pattern": "^msg_"
+              "instructions": {
+                "type": "object",
+                "patternProperties": {
+                  "^[a-z0-9][a-z0-9._-]*\\/[a-z0-9][a-z0-9._/-]*$": {
+                    "type": "string",
+                    "allOf": [
+                      {
+                        "pattern": "^[a-f0-9]{64}$"
+                      }
+                    ]
                  }
-                ]
+                }
              }
            },
            "required": [
              "sessionID",
              "parentID",
-              "parentSeq"
+              "boundary"
            ],
            "additionalProperties": false
          }
@@ -17114,6 +17183,49 @@
        ],
        "additionalProperties": false
      },
+      "Tool.FileContent1": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": [
+              "file"
+            ]
+          },
+          "uri": {
+            "type": "string"
+          },
+          "mime": {
+            "type": "string"
+          },
+          "name": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": [
+          "type",
+          "uri",
+          "mime"
+        ],
+        "additionalProperties": false
+      },
+      "Tool.Content1": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/Tool.TextContent"
+          },
+          {
+            "$ref": "#/components/schemas/Tool.FileContent1"
+          }
+        ]
+      },
      "Session.Message.ProviderState8": {
        "type": "object"
      },
@@ -17197,12 +17309,12 @@
                "type": "array",
                "prefixItems": [
                  {
-                    "$ref": "#/components/schemas/LLM.ToolContent"
+                    "$ref": "#/components/schemas/Tool.Content1"
                  }
                ],
                "minItems": 1,
                "items": {
-                  "$ref": "#/components/schemas/LLM.ToolContent"
+                  "$ref": "#/components/schemas/Tool.Content1"
                }
              },
              "metadata": {
@@ -17320,12 +17432,12 @@
                "type": "array",
                "prefixItems": [
                  {
-                    "$ref": "#/components/schemas/LLM.ToolContent"
+                    "$ref": "#/components/schemas/Tool.Content1"
                  }
                ],
                "minItems": 1,
                "items": {
-                  "$ref": "#/components/schemas/LLM.ToolContent"
+                  "$ref": "#/components/schemas/Tool.Content1"
                }
              },
              "metadata": {
@@ -207,17 +207,16 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
    .add(
      HttpApiEndpoint.post("session.fork", "/api/session/:sessionID/fork", {
        params: { sessionID: Session.ID },
-        payload: Schema.Struct({ messageID: SessionMessage.ID.pipe(Schema.optional) }),
+        payload: Schema.Struct({ boundary: Session.ForkRequestBoundary }),
        success: Schema.Struct({ data: Session.Info }),
-        error: [SessionNotFoundError, MessageNotFoundError],
+        error: [SessionNotFoundError, MessageNotFoundError, InvalidRequestError],
      })
        .middleware(sessionLocationMiddleware)
        .annotateMerge(
          OpenApi.annotations({
            identifier: "v2.session.fork",
            summary: "Fork session",
-            description:
-              "Create a child session by copying projected history from the parent. When messageID is supplied, copy messages before that boundary.",
+            description: "Create a child session by copying projected history through or before a message boundary.",
          }),
        ),
    )
@@ -22,6 +22,7 @@ import { Snapshot } from "./snapshot.js"
 import { TokenUsage } from "./token-usage.js"
 import { SessionPending } from "./session-pending.js"
 import { Project } from "./project.js"
+import { SessionFork } from "./session-fork.js"

 export { FileAttachment }

@@ -127,8 +128,8 @@ export const Forked = Event.durable({
  schema: {
    ...Base,
    parentID: SessionID,
-    parentSeq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(-1)),
-    from: SessionMessage.ID.pipe(optional),
+    boundary: SessionFork.Boundary,
+    instructions: Instruction.Values.pipe(optional),
  },
 })
 export type Forked = typeof Forked.Type
@@ -0,0 +1,16 @@
+export * as SessionFork from "./session-fork.js"
+
+import { Schema } from "effect"
+import { SessionMessage } from "./session-message.js"
+
+export const Boundary = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("before"), messageID: SessionMessage.ID }),
+  Schema.Struct({ type: Schema.Literal("through"), messageID: SessionMessage.ID }),
+]).annotate({ identifier: "Session.ForkBoundary" })
+export type Boundary = typeof Boundary.Type
+
+export const RequestBoundary = Schema.Union([
+  Schema.Struct({ type: Schema.Literal("before"), messageID: SessionMessage.ID }),
+  Schema.Struct({ type: Schema.Literal("through") }),
+]).annotate({ identifier: "Session.ForkRequestBoundary" })
+export type RequestBoundary = typeof RequestBoundary.Type
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dax Raad	bd906d468d	refactor(core): make watcher subscription effectful	2026-07-29 09:50:24 -04:00
Dax Raad	fc11ed3838	feat(session): define explicit fork boundaries	2026-07-29 09:50:24 -04:00
Dax Raad	2a85c861e0	fix(session): hide pending admission sequence	2026-07-29 09:50:24 -04:00
Shoubhit DashandGitHub	9554f9a16e	feat(ai): type Vertex request options (#39499 )	2026-07-29 18:23:00 +05:30
Shoubhit DashandGitHub	d72b428061	feat(ai): type Vertex Chat request options (#39503 )	2026-07-29 18:22:41 +05:30
Shoubhit DashandGitHub	fea17b4a0e	feat(ai): type Cloudflare request options (#39507 )	2026-07-29 18:22:16 +05:30
Shoubhit DashandGitHub	9038e44a68	feat(ai): type Copilot request options (#39496 )	2026-07-29 18:22:01 +05:30
Shoubhit DashandGitHub	3b8299e3f2	feat(ai): type Azure request options (#39498 )	2026-07-29 18:21:43 +05:30
Shoubhit DashandGitHub	f5cdf0f056	feat(ai): type Anthropic request options (#39502 )	2026-07-29 18:21:19 +05:30
Shoubhit DashandGitHub	224feff7c4	feat(ai): type compatible Responses options (#39506 )	2026-07-29 18:20:55 +05:30
Shoubhit DashandGitHub	ce2c9e7e26	feat(ai): type Google request options (#39504 )	2026-07-29 18:20:30 +05:30
Shoubhit DashandGitHub	cb80f47112	feat(ai): type Vertex Messages request options (#39501 )	2026-07-29 18:20:04 +05:30
Shoubhit DashandGitHub	b4ac939537	feat(ai): type xAI request options (#39505 )	2026-07-29 18:19:44 +05:30
Shoubhit DashandGitHub	8a96b80aec	feat(ai): type OpenAI request options (#39495 )	2026-07-29 18:19:26 +05:30
Shoubhit DashandGitHub	333a090975	feat(ai): type Vertex Responses request options (#39500 )	2026-07-29 18:19:02 +05:30
Shoubhit DashandGitHub	5a78a17e49	feat(ai): type OpenRouter request options (#39508 )	2026-07-29 18:18:43 +05:30
Shoubhit DashandGitHub	9d6af6afa4	feat(ai): type compatible request options (#39509 )	2026-07-29 18:18:24 +05:30
Shoubhit DashandGitHub	8c3e06798c	refactor(ai): limit provider option inference (#39510 )	2026-07-29 18:18:00 +05:30
Shoubhit DashandGitHub	5882b64612	feat(ai): type Anthropic-compatible request options (#39497 )	2026-07-29 18:07:24 +05:30
Shoubhit DashandGitHub	309c4fe6f0	feat(ai): infer model provider options (#39493 )	2026-07-29 18:05:56 +05:30
Shoubhit DashandGitHub	d9555f138b	refactor(ai): internalize request compilation (#39132 )	2026-07-29 16:51:11 +05:30