@opencode/core 0.0.0-beta-19500 → 0.0.0-dev-19274

package/dist/types/model-resolver.d.ts

@@ -48,53 +48,6 @@ declare const UnsupportedPackageError_base: Schema.Class<UnsupportedPackageError
 export declare class UnsupportedPackageError extends UnsupportedPackageError_base {
     get message(): string;
 }
-export declare const InitializationPhase: Schema.Literals<readonly ["load", "init", "construct"]>;
-export type InitializationPhase = typeof InitializationPhase.Type;
-declare const ModelConfigurationError_base: Schema.Class<ModelConfigurationError, Schema.TaggedStruct<"SessionRunnerModel.ModelConfigurationError", {
-    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
-        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
-        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
-        openai: string & import("effect/Brand").Brand<"Provider.ID">;
-        google: string & import("effect/Brand").Brand<"Provider.ID">;
-        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
-        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
-        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
-        azure: string & import("effect/Brand").Brand<"Provider.ID">;
-        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
-        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
-        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
-    };
-    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
-    readonly package: Schema.String;
-    readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** Provider settings are missing, conflicting, or unsupported; the provider's own message tells the user what to fix. */
-export declare class ModelConfigurationError extends ModelConfigurationError_base {
-    get message(): string;
-}
-declare const ModelInitializationError_base: Schema.Class<ModelInitializationError, Schema.TaggedStruct<"SessionRunnerModel.ModelInitializationError", {
-    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
-        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
-        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
-        openai: string & import("effect/Brand").Brand<"Provider.ID">;
-        google: string & import("effect/Brand").Brand<"Provider.ID">;
-        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
-        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
-        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
-        azure: string & import("effect/Brand").Brand<"Provider.ID">;
-        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
-        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
-        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
-    };
-    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
-    readonly package: Schema.String;
-    readonly phase: Schema.Literals<readonly ["load", "init", "construct"]>;
-    readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** A supported package failed unexpectedly while loading or constructing the model. */
-export declare class ModelInitializationError extends ModelInitializationError_base {
-    get message(): string;
-}
 declare const UnresolvedProviderVariablesError_base: Schema.Class<UnresolvedProviderVariablesError, Schema.TaggedStruct<"SessionRunnerModel.UnresolvedProviderVariablesError", {
     readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
         opencode: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -135,7 +88,7 @@ declare const UnsupportedCompactionError_base: Schema.Class<UnsupportedCompactio
 export declare class UnsupportedCompactionError extends UnsupportedCompactionError_base {
     get message(): string;
 }
-export type Error = VariantUnavailableError | UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError | Integration.AuthorizationError;
+export type Error = VariantUnavailableError | UnsupportedPackageError | UnresolvedProviderVariablesError | UnsupportedCompactionError | Integration.AuthorizationError;
 export interface Resolved {
     /** Route-level model for provider requests; its id is the provider API model id, which may differ from the catalog id. */
     readonly model: LanguageModel;
@@ -149,8 +102,6 @@ export interface Resolved {
     readonly limit: Info["limit"];
     /** Model policy overrides the provider policy; omitted means local compaction. */
     readonly compaction?: Info["compaction"];
-    /** Whether the session WebSocket may carry this model's requests when the route supports it. */
-    readonly websocket: boolean;
 }
 export interface Interface {
     readonly resolve: (requested?: Ref) => Effect.Effect<Resolved | undefined, Error>;
@@ -164,10 +115,10 @@ export interface Dependencies {
     readonly loadPackage?: (specifier: string) => Effect.Effect<Provider.ProviderPackage, Provider.LoadError>;
     readonly loadAISDK?: (model: Info) => Effect.Effect<LanguageModel, AISDK.InitError>;
 }
-export declare const fromCatalogModel: (model: Info, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel, UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError>;
+export declare const fromCatalogModel: (model: Info, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel, UnsupportedPackageError | UnresolvedProviderVariablesError | UnsupportedCompactionError>;
 export declare const resolveModel: (model: Info, variant: VariantID | undefined, credential?: Credential.Value, dependencies?: Dependencies) => Effect.Effect<LanguageModel<{
     readonly [x: string]: unknown;
-}, import("@opencode/ai/route").CompactionOperations | undefined>, VariantUnavailableError | UnsupportedPackageError | ModelConfigurationError | ModelInitializationError | UnresolvedProviderVariablesError | UnsupportedCompactionError, never>;
+}, import("@opencode/ai/route").CompactionOperations | undefined>, VariantUnavailableError | UnsupportedPackageError | UnresolvedProviderVariablesError | UnsupportedCompactionError, never>;
 export declare const hasPackage: (model: Info) => boolean;
 /** Resolves catalog selections into runtime models for the current Location. */
 export declare const layer: Layer.Layer<Service, never, Npm.Service | AISDK.Service | Integration.Service | Catalog.Service>;

package/dist/types/model.d.ts

@@ -199,7 +199,6 @@ export declare const Info: import("effect/Schema").Struct<{
         readonly mode: import("effect/Schema").Literal<"provider">;
         readonly threshold: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
 }> & {
     default: (providerID: import("@opencode/schema/provider").ID, id: Model.ID) => {
         id: string & import("effect/Brand").Brand<"Model.ID">;

package/dist/types/plugin/optimize.d.ts

@@ -1,9 +1,8 @@
 export * as OptimizePlugin from "./optimize.js";
 export declare const OpenAIPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
-export declare const AnthropicPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
 export declare const OpenAIToolsPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
 export declare const AnthropicToolsPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
 export declare const KimiPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
 export declare const ArceePlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
 export declare const MetaPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
-export declare const Plugins: readonly [import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>];
+export declare const Plugins: readonly [import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>, import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>];

package/dist/types/plugin/provider/anthropic.d.ts

@@ -0,0 +1 @@
+export declare const AnthropicPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/plugin/provider/mistral.d.ts

@@ -0,0 +1 @@
+export declare const MistralPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;

package/dist/types/plugin/provider/snowflake-cortex.d.ts

@@ -1,5 +1,4 @@
-import { HttpClient } from "effect/unstable/http";
-import { Bus } from "../../bus.js";
-import { Credential } from "../../credential.js";
-import { Integration } from "../../integration.js";
-export declare const SnowflakeCortexPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | Bus.Service | Credential.Service | Integration.Service | import("../../catalog.js").Service>;
+type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare function cortexFetch(upstream?: FetchLike): (url: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export declare const SnowflakeCortexPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope>;
+export {};

package/dist/types/provider.d.ts

@@ -35,7 +35,6 @@ export type ProviderPackage = ProviderPackageDefinition;
 export declare const loadPackage: (input: string, npm?: Npm.Interface | undefined) => Effect.Effect<ProviderPackageDefinition<import("@opencode/ai").ProviderPackageSettings, {
     readonly [x: string]: unknown;
 }, import("@opencode/ai/route").CompactionOperations | undefined>, LoadError, never>;
-export declare function nativeSettings(settings: Settings): Settings;
 export declare function mergeOverlay(base: Readonly<Record<string, unknown>> | undefined, overlay: Readonly<Record<string, unknown>> | undefined): Record<string, Json> | undefined;
 export declare function mergeHeaders(base: Readonly<Record<string, string>> | undefined, overlay: Readonly<Record<string, string>> | undefined): {
     [k: string]: string;
@@ -105,7 +104,6 @@ export declare const Info: Schema.Struct<{
         readonly mode: Schema.Literal<"provider">;
         readonly threshold: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>]>>, never, never>;
-    readonly websocket: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
 }> & {
     empty: (id: Provider.ID) => Provider.Info;
 };

package/dist/types/rpc.d.ts

@@ -8,7 +8,6 @@ export interface Interface {
     readonly register: RpcDomain["register"];
     readonly client: <D extends Rpc.Definition>(definition: D) => RpcClient<D, Rpc.SystemError, never, unknown>;
     readonly call: (rpcID: string, method: string, input: unknown) => Effect.Effect<unknown, Rpc.Failure>;
-    readonly close: Effect.Effect<void>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Rpc", Interface>;
 export declare class Service extends Service_base {

package/dist/types/session/compaction.d.ts

@@ -21,7 +21,7 @@ export type Editor = {
 };
 export type AutoInput = {
     readonly context: SessionContext.Loaded;
-    readonly prepare: SessionModelRequest.Interface["compaction"];
+    readonly prepare: SessionModelRequest.Interface["prepare"];
     /** Known overflow must recover from durable history, not submit the overflowing native window again. */
     readonly overflow?: boolean;
 };
@@ -39,7 +39,7 @@ export type ManualInput = {
     readonly resolveContext: (session: SessionSchema.Info) => Effect.Effect<SessionContext.Loaded & {
         readonly instructionUpdate: string;
     }, SessionRunnerModel.Error | AgentNotFoundError | Instructions.InitializationBlocked>;
-    readonly prepare: SessionModelRequest.Interface["compaction"];
+    readonly prepare: SessionModelRequest.Interface["prepare"];
 };
 export type Outcome = (Pick<SessionMessage.CompactionCompleted, "status"> & {
     /** Consumes the logical step's one overflow rebuild even when the native attempt overflowed first. */
@@ -59,6 +59,6 @@ export declare const estimateTokens: (input: RequiredInput) => number;
 export declare const retainUsers: (messages: readonly SessionMessage.Info[], model: Pick<SessionRunnerModel.Resolved, "ref" | "capabilities">, keepTokens: number) => Message[];
 export declare const truncateToolOutput: (value: string) => string;
 export declare const serializeToolContent: (content: SessionMessage.ToolStateCompleted["content"]) => string;
-export declare const buildPrompt: (update: boolean, legacy?: boolean) => string;
+export declare const buildPrompt: (update: boolean) => string;
 export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/context.d.ts

@@ -44,7 +44,7 @@ export interface Interface {
         readonly primary: SessionRunnerModel.Resolved | undefined;
         readonly selected: SessionRunnerModel.Resolved;
     } | undefined>;
-    readonly request: SessionModelRequest.Interface;
+    readonly prepare: SessionModelRequest.Interface["prepare"];
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionContext", Interface>;
 /** Location-scoped model-context loader for durable Session Steps. */

package/dist/types/session/error.d.ts

@@ -20,6 +20,42 @@ declare const MessageNotFoundError_base: Schema.Class<MessageNotFoundError, Sche
 }>, import("effect/Cause").YieldableError>;
 export declare class MessageNotFoundError extends MessageNotFoundError_base {
 }
+declare const MessageNotAssistantError_base: Schema.Class<MessageNotAssistantError, Schema.TaggedStruct<"Session.MessageNotAssistantError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageNotAssistantError extends MessageNotAssistantError_base {
+}
+declare const MessageIncompleteError_base: Schema.Class<MessageIncompleteError, Schema.TaggedStruct<"Session.MessageIncompleteError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageIncompleteError extends MessageIncompleteError_base {
+}
+declare const MessageToolIncompleteError_base: Schema.Class<MessageToolIncompleteError, Schema.TaggedStruct<"Session.MessageToolIncompleteError", {
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
+        fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class MessageToolIncompleteError extends MessageToolIncompleteError_base {
+}
 declare const ForkEmptyError_base: Schema.Class<ForkEmptyError, Schema.TaggedStruct<"Session.ForkEmptyError", {
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;

package/dist/types/session/history.d.ts

@@ -343,7 +343,6 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
     readonly model?: {
         readonly id: string & import("effect/Brand").Brand<"Model.ID">;
         readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -352,15 +351,6 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly providerState?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly tokens?: {
-        readonly input: number;
-        readonly output: number;
-        readonly reasoning: number;
-        readonly cache: {
-            readonly read: number;
-            readonly write: number;
-        };
-    } | undefined;
     readonly providerContext?: {
         readonly version: 1;
         readonly provenance: {
@@ -389,16 +379,6 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
-    readonly tokens?: {
-        readonly input: number;
-        readonly output: number;
-        readonly reasoning: number;
-        readonly cache: {
-            readonly read: number;
-            readonly write: number;
-        };
-    } | undefined;
 }, MessageDecodeError, never>;
 export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/unstable/sql/SqlClient").SqlClient;
@@ -731,7 +711,6 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
     readonly model?: {
         readonly id: string & import("effect/Brand").Brand<"Model.ID">;
         readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -740,15 +719,6 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly providerState?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly tokens?: {
-        readonly input: number;
-        readonly output: number;
-        readonly reasoning: number;
-        readonly cache: {
-            readonly read: number;
-            readonly write: number;
-        };
-    } | undefined;
     readonly providerContext?: {
         readonly version: 1;
         readonly provenance: {
@@ -777,16 +747,6 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
-    readonly tokens?: {
-        readonly input: number;
-        readonly output: number;
-        readonly reasoning: number;
-        readonly cache: {
-            readonly read: number;
-            readonly write: number;
-        };
-    } | undefined;
 })[], MessageDecodeError, never>;
 export declare const entriesForRunner: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/unstable/sql/SqlClient").SqlClient;
@@ -1123,7 +1083,6 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-            readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
             readonly model?: {
                 readonly id: string & import("effect/Brand").Brand<"Model.ID">;
                 readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -1132,15 +1091,6 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly providerState?: {
                 readonly [x: string]: unknown;
             } | undefined;
-            readonly tokens?: {
-                readonly input: number;
-                readonly output: number;
-                readonly reasoning: number;
-                readonly cache: {
-                    readonly read: number;
-                    readonly write: number;
-                };
-            } | undefined;
             readonly providerContext?: {
                 readonly version: 1;
                 readonly provenance: {
@@ -1169,16 +1119,6 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
-            readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
-            readonly tokens?: {
-                readonly input: number;
-                readonly output: number;
-                readonly reasoning: number;
-                readonly cache: {
-                    readonly read: number;
-                    readonly write: number;
-                };
-            } | undefined;
         };
     }[];
 }, never, never>;
@@ -1515,7 +1455,6 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly metadata?: {
             readonly [x: string]: unknown;
         } | undefined;
-        readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
         readonly model?: {
             readonly id: string & import("effect/Brand").Brand<"Model.ID">;
             readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
@@ -1524,15 +1463,6 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly providerState?: {
             readonly [x: string]: unknown;
         } | undefined;
-        readonly tokens?: {
-            readonly input: number;
-            readonly output: number;
-            readonly reasoning: number;
-            readonly cache: {
-                readonly read: number;
-                readonly write: number;
-            };
-        } | undefined;
         readonly providerContext?: {
             readonly version: 1;
             readonly provenance: {
@@ -1561,16 +1491,6 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly metadata?: {
             readonly [x: string]: unknown;
         } | undefined;
-        readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
-        readonly tokens?: {
-            readonly input: number;
-            readonly output: number;
-            readonly reasoning: number;
-            readonly cache: {
-                readonly read: number;
-                readonly write: number;
-            };
-        } | undefined;
     })[];
     instructionUpdate: string;
 }, Instructions.InitializationBlocked, never>;

package/dist/types/session/model-request.d.ts

@@ -1,7 +1,7 @@
 export * as SessionModelRequest from "./model-request.js";
 import { LLM, LLMRequest, Message, SystemPart } from "@opencode/ai";
 import type { StreamOptions } from "@opencode/ai/route";
-import type { SessionCompaction, SessionContext, SessionGenerate, SessionRequest, SessionTitle } from "@opencode/plugin/effect/session";
+import type { SessionRequestKind } from "@opencode/plugin/effect/session";
 import type { Agent } from "@opencode/schema/agent";
 import type { Model } from "@opencode/schema/model";
 import { Context, Effect, Layer } from "effect";
@@ -13,25 +13,41 @@ import { SessionModelTransport } from "./model-transport.js";
 import { SessionRunnerModel } from "./runner/model.js";
 import { SessionSchema } from "./schema.js";
 import type { SessionMessage } from "./message.js";
-/** Tool errors, plus the user declining a permission or dismissing a question. */
+/** Failures a prepared execution can surface: infrastructure errors plus user declines resurfaced from the defect tunnel. */
 export type ExecuteError = Tool.Error | Permission.DeclinedError | QuestionTool.CancelledError;
-export interface Prepared<Event = SessionRequest> {
-    readonly event: Event;
+export interface Prepared {
     readonly request: LLMRequest;
     readonly options: StreamOptions;
     readonly retry: (event: PluginHooks.Domains["session"]["retry"]) => Effect.Effect<void>;
-    /** Runs a tool call against the tools this request advertised. */
+    /**
+     * One request-scoped execution operation. Unknown and hook-removed calls
+     * fail individually through the same seam.
+     */
     readonly executeTool: (input: Parameters<Tool.Snapshot["execute"]>[0]) => Effect.Effect<Tool.NormalizedResult, ExecuteError>;
 }
-export interface Input {
-    readonly session: SessionSchema.Info;
-    readonly agent: Agent.ID;
-    readonly model: SessionRunnerModel.Resolved;
-    readonly tools?: Tool.Snapshot;
-    readonly system: Array<SystemPart>;
-    readonly messages: Array<Message>;
+interface PrepareInput {
+    /** Which Session flow issues this request; request hooks receive it alongside the Session identity. */
+    readonly kind: SessionRequestKind;
+    readonly scope: {
+        readonly session: SessionSchema.Info;
+        readonly agentID: Agent.ID;
+        /** Agent whose context an auxiliary request reuses, without changing its request-hook identity. */
+        readonly contextAgentID?: Agent.ID;
+        readonly model: SessionRunnerModel.Resolved;
+        /** Omitted for requests that carry no tool definitions, such as titles. */
+        readonly tools?: Tool.Snapshot;
+    };
+    readonly transcript: {
+        readonly system: Array<SystemPart>;
+        readonly messages: Array<Message>;
+    };
     readonly toolChoice?: LLM.RequestInput["toolChoice"];
-    /** Only the durable runner may use a stateful WebSocket. */
+    /**
+     * Session context hooks shape the agent conversation. Standalone requests
+     * such as titles opt out; compaction uses the selected Session context.
+     */
+    readonly contextHooks?: false;
+    /** Stateful Session WebSocket channels require an explicit durable-runner opt-in. */
     readonly webSocket?: "session";
 }
 export declare const baseTranscript: (input: {
@@ -54,14 +70,17 @@ export declare const baseTranscript: (input: {
 };
 export declare const unsupportedParts: (messages: LLMRequest["messages"], capabilities: Model.Capabilities) => Message[];
 export declare const boundImages: (messages: LLMRequest["messages"]) => readonly Message[];
-/** Builds the model request for each session flow. Each entry runs its own plugin hook. */
+/**
+ * Builds an outbound model request and captures the tool-call capability that
+ * must remain paired with it. It does not execute the request or mutate
+ * Session state.
+ */
 export interface Interface {
-    readonly primary: (input: Input) => Effect.Effect<Prepared<SessionContext>>;
-    readonly compaction: (input: Input) => Effect.Effect<Prepared<SessionCompaction>>;
-    readonly generate: (input: Input) => Effect.Effect<Prepared<SessionGenerate>>;
-    readonly title: (input: Input) => Effect.Effect<Prepared<SessionTitle>>;
+    /** Builds one outbound model request and its matching tool-call capability. */
+    readonly prepare: (input: PrepareInput) => Effect.Effect<Prepared>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionModelRequest", Interface>;
+/** Location-scoped outbound model-request preparation. */
 export declare class Service extends Service_base {
 }
 export declare const layer: Layer.Layer<Service, never, PluginHooks.Service | SessionModelTransport.Service>;

package/dist/types/session/runner/model.d.ts

@@ -37,10 +37,6 @@ export declare const VariantUnavailableError: typeof ModelResolver.VariantUnavai
 export type VariantUnavailableError = ModelResolver.VariantUnavailableError;
 export declare const UnsupportedPackageError: typeof ModelResolver.UnsupportedPackageError;
 export type UnsupportedPackageError = ModelResolver.UnsupportedPackageError;
-export declare const ModelConfigurationError: typeof ModelResolver.ModelConfigurationError;
-export type ModelConfigurationError = ModelResolver.ModelConfigurationError;
-export declare const ModelInitializationError: typeof ModelResolver.ModelInitializationError;
-export type ModelInitializationError = ModelResolver.ModelInitializationError;
 export declare const UnresolvedProviderVariablesError: typeof ModelResolver.UnresolvedProviderVariablesError;
 export type UnresolvedProviderVariablesError = ModelResolver.UnresolvedProviderVariablesError;
 export declare const UnsupportedCompactionError: typeof ModelResolver.UnsupportedCompactionError;
@@ -61,6 +57,5 @@ export declare const resolved: (model: LanguageModel, options: {
     readonly cost: Model.Info["cost"];
     readonly limit: Model.Info["limit"];
     readonly compaction?: Provider.Compaction;
-    readonly websocket?: boolean;
 }) => Resolved;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/session/runner/step.d.ts

@@ -156,7 +156,7 @@ interface Input {
     readonly assistantMessageID: SessionMessage.ID;
     readonly agent: Agent.ID;
     readonly model: SessionRunnerModel.Resolved;
-    readonly prepared: Omit<SessionModelRequest.Prepared, "event">;
+    readonly prepared: SessionModelRequest.Prepared;
     readonly retry: (cause: AIError, error: SessionError.Error, retry: boolean) => Effect.Effect<{
         readonly retry: false;
     } | SessionRunnerRetry.Decision>;

package/dist/types/session/schema.d.ts

@@ -136,15 +136,6 @@ export declare const Info: import("effect/Schema").Struct<{
     }>;
     readonly subpath: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "RelativePath">>, never, never>;
     readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>>>, never, never>;
-    readonly permissions: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly action: import("effect/Schema").String;
-        readonly resource: import("effect/Schema").String;
-        readonly effect: import("effect/Schema").Literals<readonly ["allow", "deny", "ask"]>;
-    }>>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly action: import("effect/Schema").String;
-        readonly resource: import("effect/Schema").String;
-        readonly effect: import("effect/Schema").Literals<readonly ["allow", "deny", "ask"]>;
-    }>>>, never, never>;
     readonly revert: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly messageID: import("effect/Schema").brand<import("effect/Schema").String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/types/session/session.d.ts

@@ -2,14 +2,13 @@ export * as Session from "./session.js";
 import { DateTime, Effect, Scope } from "effect";
 import type { Agent } from "@opencode/schema/agent";
 import type { Model } from "@opencode/schema/model";
-import type { Permission } from "@opencode/schema/permission";
 import { Event } from "@opencode/schema/event";
 import { FSUtil } from "@opencode/util/fs-util";
 import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
 import { Instance } from "../instance/service.js";
 import type { Skill } from "../skill.js";
-import { BusyError, CompactionConflictError, InboxConflictError, MessageNotFoundError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
+import { BusyError, CompactionConflictError, InboxConflictError, MessageIncompleteError, MessageNotAssistantError, MessageNotFoundError, MessageToolIncompleteError, NotFoundError, PromptConflictError, SyntheticConflictError } from "./error.js";
 import { SessionExecution } from "./execution.js";
 import { SessionInbox } from "./inbox.js";
 import { SessionMessage } from "./message.js";
@@ -29,15 +28,16 @@ export declare const make: () => Effect.Effect<{
         id: string & import("effect/Brand").Brand<"SessionID">;
         get: () => Effect.Effect<SessionSchema.Info, NotFoundError, never>;
         message: (messageID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<SessionMessage.Info | undefined, never, never>;
+        updateMessage: (input: {
+            readonly messageID: SessionMessage.ID;
+            readonly content: readonly SessionMessage.AssistantContent[];
+        }) => Effect.Effect<SessionMessage.Assistant, NotFoundError | MessageNotFoundError | MessageNotAssistantError | MessageIncompleteError | MessageToolIncompleteError | BusyError, never>;
         view: (input: {
             idle: number;
         }) => Effect.Effect<void, NotFoundError, never>;
         rename: (input: {
             title: string;
         }) => Effect.Effect<void, NotFoundError, never>;
-        setPermissions: (input: {
-            permissions: Permission.Ruleset;
-        }) => Effect.Effect<void, NotFoundError, never>;
         switchAgent: (input: {
             agent: Agent.ID;
         }) => Effect.Effect<void, NotFoundError, never>;

package/dist/types/session/sql.d.ts

@@ -551,9 +551,9 @@ export declare const SessionTable: import("drizzle-orm/sqlite-core").SQLiteTable
             tableName: "session_v2";
             dataType: "object json";
             data: readonly {
-                readonly action: string;
-                readonly resource: string;
-                readonly effect: "allow" | "deny" | "ask";
+                readonly permission: string;
+                readonly pattern: string;
+                readonly action: "allow" | "deny" | "ask";
             }[];
             driverParam: string;
             notNull: false;

package/dist/types/session/store.d.ts

@@ -74,7 +74,6 @@ export type MessagesInput = {
     sessionID: Session.ID;
     limit?: number;
     order?: "asc" | "desc";
-    type?: SessionMessage.Type;
     cursor?: {
         id: SessionMessage.ID;
         direction: "previous" | "next";