@opencode/core 2.0.18 → 2.0.20

package/dist/types/integration/connection.d.ts

@@ -7,11 +7,29 @@ export declare const CredentialInfo: import("effect/Schema").Struct<{
     };
     readonly label: import("effect/Schema").String;
     readonly method: import("effect/Schema").Literals<readonly ["key", "oauth"]>;
+    readonly status: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>, never, never>;
 }>;
 export type CredentialInfo = Connection.CredentialInfo;
 export declare const EnvInfo: import("effect/Schema").Struct<{
     readonly type: import("effect/Schema").Literal<"env">;
     readonly name: import("effect/Schema").String;
+    readonly status: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>, never, never>;
 }>;
 export type EnvInfo = Connection.EnvInfo;
 export declare const Info: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
@@ -21,11 +39,35 @@ export declare const Info: import("effect/Schema").Union<readonly [import("effec
     };
     readonly label: import("effect/Schema").String;
     readonly method: import("effect/Schema").Literals<readonly ["key", "oauth"]>;
+    readonly status: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>, never, never>;
 }>, import("effect/Schema").Struct<{
     readonly type: import("effect/Schema").Literal<"env">;
     readonly name: import("effect/Schema").String;
+    readonly status: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+        readonly message: import("effect/Schema").String;
+        readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+    }>>, never, never>;
 }>]>;
 export type Info = Connection.Info;
+export declare const Status: import("effect/Schema").Struct<{
+    readonly status: import("effect/Schema").Literals<readonly ["needs_auth"]>;
+    readonly message: import("effect/Schema").String;
+    readonly url: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
+}>;
+export type Status = Connection.Status;
 /** Identity of an access choice; labels and refreshed token values do not identify a new connection. */
 export declare function key(connection: {
     readonly type: "credential";

package/dist/types/integration.d.ts

@@ -1502,9 +1502,27 @@ export declare const Info: Schema.Struct<{
         };
         readonly label: Schema.String;
         readonly method: Schema.Literals<readonly ["key", "oauth"]>;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["needs_auth"]>;
+            readonly message: Schema.String;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["needs_auth"]>;
+            readonly message: Schema.String;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>, never, never>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"env">;
         readonly name: Schema.String;
+        readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["needs_auth"]>;
+            readonly message: Schema.String;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["needs_auth"]>;
+            readonly message: Schema.String;
+            readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>, never, never>;
     }>]>>;
 }>;
 export type Info = Integration.Info;
@@ -1676,6 +1694,12 @@ export interface Interface extends State.Transformable<Editor> {
         readonly update: (credentialID: Credential.ID, updates: Partial<Pick<Credential.Info, "label">>) => Effect.Effect<void>;
         /** Removes a stored credential connection. */
         readonly remove: (credentialID: Credential.ID) => Effect.Effect<void>;
+        /** Reports or clears a runtime problem with a connection; `get` and `list` project it onto the connection. */
+        readonly status: (input: {
+            readonly integrationID: ID;
+            readonly connection: IntegrationConnection.Info;
+            readonly status: IntegrationConnection.Status | undefined;
+        }) => Effect.Effect<void>;
     };
     readonly oauth: {
         /** Starts a stateful OAuth attempt. */

package/dist/types/location-services.d.ts

@@ -4,5 +4,4 @@ import { Instance } from "./instance.js";
 import { LocationServiceMap } from "./location-service-map.js";
 export { LocationServiceMap } from "./location-service-map.js";
 export type LocationServices = Instance.Services;
-export type LocationError = Instance.Error;
 export declare function buildLocationServiceMap(replacements?: LayerNode.Replacements): Layer.Layer<LocationServiceMap.Service>;

package/dist/types/location.d.ts

@@ -11,6 +11,4 @@ declare const Service_base: Context.ServiceClass<Service, "@opencode/Location",
 export declare class Service extends Service_base {
 }
 export declare const node: LayerNode.Node<Service, never, LayerNode.Tag<"location">>;
-export declare const boundNode: (ref: Ref, options?: {
-    readonly discovery?: boolean;
-}) => LayerNode.Provider<Service, never, LayerNode.Tag<"location">>;
+export declare const boundNode: (ref: Ref) => LayerNode.Provider<Service, never, LayerNode.Tag<"location">>;

package/dist/types/mcp/index.d.ts

@@ -118,18 +118,6 @@ export declare const ResourceCatalog: Schema.Struct<{
     }>>;
 }>;
 export type ResourceCatalog = Mcp.ResourceCatalog;
-export declare const ResourceContentPart: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"text">;
-    readonly uri: Schema.String;
-    readonly text: Schema.String;
-    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"blob">;
-    readonly uri: Schema.String;
-    readonly blob: Schema.String;
-    readonly mimeType: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>]>;
-export type ResourceContentPart = Mcp.ResourceContentPart;
 export declare const ResourceContent: Schema.Struct<{
     readonly server: Schema.String;
     readonly uri: Schema.String;

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

@@ -0,0 +1,33 @@
+import { Effect, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import { App } from "../../app.js";
+import { Credential } from "../../credential.js";
+import { Bus } from "../../bus.js";
+import { Model } from "../../model.js";
+declare const RemoteModel: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly display_name: Schema.String;
+    readonly visibility: Schema.String;
+    readonly supported_in_api: Schema.Boolean;
+    readonly context_window: Schema.Int;
+    readonly input_modalities: Schema.$Array<Schema.String>;
+    readonly supported_reasoning_levels: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly effort: Schema.String;
+    }>>>;
+}>;
+type RemoteModel = typeof RemoteModel.Type;
+export declare const ChatGPTPlugin: import("@opencode/plugin/effect/plugin").Plugin<import("effect/Scope").Scope | HttpClient.HttpClient | Bus.Service | Credential.Service>;
+export declare function fetchModels(token: string, app: App.Info, baseURL?: string): Effect.Effect<{
+    readonly slug: string;
+    readonly input_modalities: readonly string[];
+    readonly display_name: string;
+    readonly visibility: string;
+    readonly supported_in_api: boolean;
+    readonly context_window: number;
+    readonly supported_reasoning_levels?: readonly {
+        readonly effort: string;
+    }[] | undefined;
+}[], Error | import("effect/unstable/http/HttpClientError").HttpClientError | Schema.SchemaError, HttpClient.HttpClient>;
+export declare function deriveModels(remote: ReadonlyArray<RemoteModel>, existing: ReadonlyArray<Model.Info>): import("@opencode/schema/model").Info[];
+export declare function verifyIDToken(token: string, clientID: string, nonce: string, jwksURL?: URL): Effect.Effect<void, Error, never>;
+export {};

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

@@ -1,4 +1,4 @@
-import type { Scope } from "effect";
+import { Scope } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import { Bus } from "../../bus.js";
 import { ManagedPolicy } from "../../managed-policy.js";

package/dist/types/project.d.ts

@@ -93,9 +93,7 @@ export interface Interface {
     /** Records Project activity for recency ordering, at most once per minute per Project. */
     readonly activate: (projectID: ID) => Effect.Effect<void>;
     /** Resolves and persists the owning Project. */
-    readonly resolve: (input: AbsolutePath, options?: {
-        readonly discovery?: boolean;
-    }) => Effect.Effect<Resolved>;
+    readonly resolve: (input: AbsolutePath) => Effect.Effect<Resolved>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Project", Interface>;
 export declare class Service extends Service_base {

package/dist/types/pty/ticket.d.ts

@@ -1,13 +1,13 @@
 export * as PtyTicket from "./ticket.js";
 import type { Workspace } from "@opencode/schema/workspace";
-import { PtyID } from "./schema.js";
+import type { Pty } from "@opencode/schema/pty";
 import { Context, Duration, Effect } from "effect";
 export declare const ConnectToken: import("effect/Schema").Struct<{
     readonly ticket: import("effect/Schema").String;
     readonly expires_in: import("effect/Schema").Int;
 }>;
 export type Scope = {
-    readonly ptyID: PtyID;
+    readonly ptyID: Pty.ID;
     readonly directory?: string;
     readonly workspaceID?: Workspace.ID;
 };

package/dist/types/pty.d.ts

@@ -1,6 +1,11 @@
 export * as Pty from "./pty.js";
 import { Context, Effect, Schema, Types } from "effect";
-import { PtyID } from "./pty/schema.js";
+import { Pty } from "@opencode/schema/pty";
+export declare const ID: Schema.brand<Schema.String, "PtyID"> & {
+    create: () => string & import("effect/Brand").Brand<"PtyID">;
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"PtyID">;
+};
+export type ID = Pty.ID;
 export declare const Info: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "PtyID"> & {
         create: () => string & import("effect/Brand").Brand<"PtyID">;
@@ -67,12 +72,12 @@ export declare class ExitedError extends ExitedError_base {
 }
 export interface Interface {
     readonly list: () => Effect.Effect<Info[]>;
-    readonly get: (id: PtyID) => Effect.Effect<Info, NotFoundError>;
+    readonly get: (id: ID) => Effect.Effect<Info, NotFoundError>;
     readonly create: (input: CreateInput) => Effect.Effect<Info>;
-    readonly update: (id: PtyID, input: UpdateInput) => Effect.Effect<Info, NotFoundError>;
-    readonly remove: (id: PtyID) => Effect.Effect<void, NotFoundError>;
-    readonly write: (id: PtyID, data: string) => Effect.Effect<void, NotFoundError>;
-    readonly attach: (id: PtyID, input: AttachInput) => Effect.Effect<Attachment, NotFoundError | ExitedError>;
+    readonly update: (id: ID, input: UpdateInput) => Effect.Effect<Info, NotFoundError>;
+    readonly remove: (id: ID) => Effect.Effect<void, NotFoundError>;
+    readonly write: (id: ID, data: string) => Effect.Effect<void, NotFoundError>;
+    readonly attach: (id: ID, input: AttachInput) => Effect.Effect<Attachment, NotFoundError | ExitedError>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Pty", Interface>;
 export declare class Service extends Service_base {

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

@@ -0,0 +1,4 @@
+export * as SessionAffinity from "./affinity.js";
+import type { SessionSchema } from "./schema.js";
+/** The Session ID that groups model requests for provider cache routing: children share the parent's, forks the fork source's. */
+export declare const get: (session: Pick<SessionSchema.Info, "id" | "parentID" | "fork">) => string & import("effect/Brand").Brand<"SessionID">;

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

@@ -1,79 +1,59 @@
 export * as SessionCompaction from "./compaction.js";
-import { AIError, LLMRequest, Message, type Usage } from "@opencode/ai";
-import type { StreamOptions } from "@opencode/ai/route";
+import { Message } from "@opencode/ai";
+import type { SessionError } from "@opencode/schema/session-error";
 import { Context, Effect, Layer } from "effect";
 import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
+import { State } from "../state.js";
 import type { SessionContext } from "./context.js";
 import type { SessionMessage } from "./message.js";
 import { SessionModelRequest } from "./model-request.js";
-import type { SessionRunnerModel } from "./runner/model.js";
-import { SessionSchema } from "./schema.js";
-import { State } from "../state.js";
-import type { AgentNotFoundError } from "./error.js";
-import type { Instructions } from "../instructions/index.js";
 export type Settings = {
     auto: boolean;
-    buffer: number;
-    tokens: number;
-};
-export type NativeInput = {
-    readonly request: LLMRequest;
-    readonly options: StreamOptions;
-    /** Whole, real user messages within the retained-token allowance, for checkpoint-only mechanisms. */
-    readonly retained: Effect.Effect<ReadonlyArray<Message>>;
+    /** Tokens kept free below the model's limits before compacting. Unset keeps 10% free. */
+    buffer?: number;
+    /** Tokens of recent conversation kept verbatim beside the summary. */
+    keep: number;
 };
-export type NativeResult = {
-    readonly replacement: ReadonlyArray<Message>;
-    readonly usage?: Usage;
-};
-/** Returns the provider's replacement window, or `undefined` when this strategy has no mechanism for the route. */
-export type NativeStrategy = (input: NativeInput) => Effect.Effect<NativeResult, AIError> | undefined;
 export type Editor = {
     configure: (settings: Partial<Settings>) => void;
-    /** Later registrations take precedence. */
-    native: (strategy: NativeStrategy) => void;
 };
-export type AutoInput = {
+export type Trigger = 
+/** `overflow`: the provider just rejected this context as too long. */
+{
+    readonly reason: "auto" | "overflow";
     readonly context: SessionContext.Loaded;
-    readonly prepare: SessionModelRequest.Interface["compaction"];
-    /** Known overflow must recover from durable history, not submit the overflowing native window again. */
-    readonly overflow?: boolean;
-};
-type RequiredInput = {
-    readonly messages: readonly SessionMessage.Info[];
-    readonly resolved: SessionRunnerModel.Resolved;
+}
+/** `inputID` is the `/compact` inbox item, whose message shows the outcome. */
+ | {
+    readonly reason: "manual";
     readonly context: SessionContext.Loaded;
-};
-export type ManualInput = {
-    readonly session: SessionSchema.Info;
-    readonly messages: readonly SessionMessage.Info[];
     readonly inputID: SessionMessage.ID;
-    readonly started?: boolean;
-    /** Empty compaction controls do not preflight model or instruction availability. */
-    readonly resolveContext: (session: SessionSchema.Info) => Effect.Effect<SessionContext.Loaded & {
-        readonly instructionUpdate: string;
-    }, SessionRunnerModel.Error | AgentNotFoundError | Instructions.InitializationBlocked>;
-    readonly prepare: SessionModelRequest.Interface["compaction"];
 };
-export type Outcome = (Pick<SessionMessage.CompactionCompleted, "status"> & {
-    /** Consumes the logical step's one overflow rebuild even when the native attempt overflowed first. */
-    readonly recoveredOverflow?: boolean;
-}) | Pick<SessionMessage.CompactionFailed, "status" | "error">;
+export type Outcome = 
+/** Only `auto` skips: the context fits, or automatic compaction is off. */
+{
+    readonly status: "skipped";
+} | {
+    readonly status: "completed";
+} | {
+    readonly status: "failed";
+    readonly error: SessionError.Error;
+};
 export interface Interface extends State.Transformable<Editor> {
-    readonly enabled: () => boolean;
-    readonly required: (input: RequiredInput) => boolean;
-    readonly compact: (input: AutoInput) => Effect.Effect<Outcome>;
-    readonly compactManual: (input: ManualInput) => Effect.Effect<Outcome>;
+    readonly compact: (trigger: Trigger) => Effect.Effect<Outcome>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionCompaction", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const estimateTokens: (input: RequiredInput) => number;
-/** Keep whole, real user messages, never synthetic guidance or half an attachment/tool exchange. */
-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 layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService>;
+export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService | SessionModelRequest.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+/** The newest whole, real user messages within `keep` tokens: no synthetic guidance, no half of an attachment. */
+export declare const recentUserMessages: (messages: ReadonlyArray<SessionMessage.Info>, model: Pick<SessionContext.Loaded["model"], "ref" | "capabilities">, keep: number) => Message[];
+export declare const estimateContext: (context: SessionContext.Loaded) => number;
+/** The prompt size: `measured` is what the provider reported at the latest response, `estimated` is the text since. */
+export declare const estimatePrompt: (context: SessionContext.Loaded) => {
+    measured: number;
+    estimated: number;
+};

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

@@ -39,10 +39,4 @@ export declare const turn: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly from?: SessionMessage.ID;
     readonly to?: SessionMessage.ID;
     readonly context?: number;
-}) => Effect.Effect<readonly {
-    readonly file: string;
-    readonly patch: string;
-    readonly additions: number;
-    readonly deletions: number;
-    readonly status: "added" | "deleted" | "modified";
-}[], MessageNotFoundError | Snapshot.Error | TurnRangeError, never>;
+}) => Effect.Effect<readonly import("@opencode/schema/file-diff").Info[], MessageNotFoundError | Snapshot.Error | TurnRangeError, never>;

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

@@ -57,15 +57,16 @@ declare const StepFailedError_base: Schema.Class<StepFailedError, Schema.TaggedS
         readonly type: Schema.String;
         readonly message: Schema.String;
         readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly body: Schema.String;
+        }>>, never, never>;
     }>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StepFailedError extends StepFailedError_base {
     get message(): string;
 }
-declare const UserInterruptedError_base: Schema.Class<UserInterruptedError, Schema.TaggedStruct<"Session.UserInterruptedError", {}>, import("effect/Cause").YieldableError>;
-export declare class UserInterruptedError extends UserInterruptedError_base {
-    get message(): string;
-}
 declare const PromptConflictError_base: Schema.Class<PromptConflictError, Schema.TaggedStruct<"Session.PromptConflictError", {
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;

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

@@ -228,6 +228,9 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
                 readonly type: string;
                 readonly message: string;
                 readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
             };
             readonly metadata?: {
                 readonly [x: string]: Schema.Json;
@@ -288,6 +291,9 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
         readonly type: string;
         readonly message: string;
         readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
     } | undefined;
     readonly providerState?: {
         readonly [x: string]: unknown;
@@ -315,6 +321,9 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
             readonly type: string;
             readonly message: string;
             readonly status?: number | undefined;
+            readonly response?: {
+                readonly body: string;
+            } | undefined;
         };
     } | undefined;
 } | {
@@ -384,6 +393,9 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
         readonly type: string;
         readonly message: string;
         readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
     };
     readonly reason: "auto" | "manual";
     readonly metadata?: {
@@ -626,6 +638,9 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
                 readonly type: string;
                 readonly message: string;
                 readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
             };
             readonly metadata?: {
                 readonly [x: string]: Schema.Json;
@@ -686,6 +701,9 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
         readonly type: string;
         readonly message: string;
         readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
     } | undefined;
     readonly providerState?: {
         readonly [x: string]: unknown;
@@ -713,6 +731,9 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
             readonly type: string;
             readonly message: string;
             readonly status?: number | undefined;
+            readonly response?: {
+                readonly body: string;
+            } | undefined;
         };
     } | undefined;
 } | {
@@ -782,6 +803,9 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
         readonly type: string;
         readonly message: string;
         readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
     };
     readonly reason: "auto" | "manual";
     readonly metadata?: {
@@ -1028,6 +1052,9 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
                         readonly type: string;
                         readonly message: string;
                         readonly status?: number | undefined;
+                        readonly response?: {
+                            readonly body: string;
+                        } | undefined;
                     };
                     readonly metadata?: {
                         readonly [x: string]: Schema.Json;
@@ -1088,6 +1115,9 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
                 readonly type: string;
                 readonly message: string;
                 readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
             } | undefined;
             readonly providerState?: {
                 readonly [x: string]: unknown;
@@ -1115,6 +1145,9 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
                     readonly type: string;
                     readonly message: string;
                     readonly status?: number | undefined;
+                    readonly response?: {
+                        readonly body: string;
+                    } | undefined;
                 };
             } | undefined;
         } | {
@@ -1184,6 +1217,9 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
                 readonly type: string;
                 readonly message: string;
                 readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
             };
             readonly reason: "auto" | "manual";
             readonly metadata?: {
@@ -1430,6 +1466,9 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
                     readonly type: string;
                     readonly message: string;
                     readonly status?: number | undefined;
+                    readonly response?: {
+                        readonly body: string;
+                    } | undefined;
                 };
                 readonly metadata?: {
                     readonly [x: string]: Schema.Json;
@@ -1490,6 +1529,9 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
             readonly type: string;
             readonly message: string;
             readonly status?: number | undefined;
+            readonly response?: {
+                readonly body: string;
+            } | undefined;
         } | undefined;
         readonly providerState?: {
             readonly [x: string]: unknown;
@@ -1517,6 +1559,9 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
                 readonly type: string;
                 readonly message: string;
                 readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
             };
         } | undefined;
     } | {
@@ -1586,6 +1631,9 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
             readonly type: string;
             readonly message: string;
             readonly status?: number | undefined;
+            readonly response?: {
+                readonly body: string;
+            } | undefined;
         };
         readonly reason: "auto" | "manual";
         readonly metadata?: {

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

@@ -33,6 +33,11 @@ export interface Input {
     readonly toolChoice?: LLM.RequestInput["toolChoice"];
     /** Only the durable runner may use a stateful WebSocket. */
     readonly webSocket?: "session";
+    /** Prompt size, measured by the provider or estimated. The default output limit leaves room for it. */
+    readonly inputTokens?: {
+        readonly measured: number;
+        readonly estimated: number;
+    };
 }
 export declare const baseTranscript: (input: {
     readonly agent: Agent.Info;

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

@@ -15,13 +15,7 @@ export declare const stage: (input: {
 }) => Effect.Effect<{
     messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
     snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
-    files: readonly {
-        readonly file: string;
-        readonly patch: string;
-        readonly additions: number;
-        readonly deletions: number;
-        readonly status: "added" | "deleted" | "modified";
-    }[];
+    files: readonly import("@opencode/schema/file-diff").Info[];
 }, MessageNotFoundError | Snapshot.Error, Database.Service | Bus.Service | Instance.Service>;
 export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, Snapshot.Error, Bus.Service | Instance.Service>;
 export declare const commit: (bus: Bus.Interface, session: SessionSchema.Info) => Effect.Effect<void, never, never>;

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

@@ -3,10 +3,10 @@ import type { AIError } from "@opencode/ai";
 import { Context, Data, Effect } from "effect";
 import { SessionSchema } from "../schema.js";
 import type { Promotable } from "../inbox.js";
-import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js";
+import type { AgentNotFoundError, MessageDecodeError, StepFailedError } from "../error.js";
 import { SessionRunnerModel } from "./model.js";
 import type { Instructions } from "../../instructions/index.js";
-export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | UserInterruptedError | Instructions.InitializationBlocked;
+export type RunError = AIError | SessionRunnerModel.Error | MessageDecodeError | AgentNotFoundError | StepFailedError | Instructions.InitializationBlocked;
 export type Continuation = {
     readonly step: number;
 };

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

@@ -33,18 +33,6 @@ declare const ModelUnavailableError_base: Schema.Class<ModelUnavailableError, Sc
 export declare class ModelUnavailableError extends ModelUnavailableError_base {
     get message(): string;
 }
-export declare const VariantUnavailableError: typeof ModelResolver.VariantUnavailableError;
-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;
-export type UnsupportedCompactionError = ModelResolver.UnsupportedCompactionError;
 export type Error = ModelNotSelectedError | ModelUnavailableError | ModelResolver.Error;
 export type Resolved = ModelResolver.Resolved;
 export interface Interface {