@opencode/core 2.0.31 → 2.1.0

package/dist/types/session/instruction-entry.d.ts

@@ -11,9 +11,9 @@ export declare const Info: Schema.Struct<{
 }>;
 export type Info = typeof Info.Type;
 export declare const Snapshot: Schema.$Array<Schema.Struct<{
-    readonly removed: Schema.Boolean;
     readonly key: Schema.String;
     readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly removed: Schema.Boolean;
 }>>;
 export type Snapshot = typeof Snapshot.Type;
 export declare const MaxValueBytes: number;
@@ -28,9 +28,9 @@ export declare const snapshot: (db: import("../database/drizzle.js").EffectSQLit
 export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, entries: readonly {
-    readonly removed: boolean;
     readonly key: string;
     readonly value: Schema.Json;
+    readonly removed: boolean;
 }[], created: number) => Effect.Effect<void, never, never>;
 export interface Interface {
     readonly list: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Info>>;

package/dist/types/session/instruction-state.d.ts

@@ -21,7 +21,7 @@ export declare const prepare: (db: import("../database/drizzle.js").EffectSQLite
 export declare const apply: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, seq: number, delta: {
-    readonly [x: string]: (string & import("effect/Brand").Brand<"Instruction.Hash">) | "removed";
+    readonly [x: string]: "removed" | (string & import("effect/Brand").Brand<"Instruction.Hash">);
 }) => Effect.Effect<void, never, never>;
 export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;
@@ -29,9 +29,13 @@ export declare const initialize: (db: import("../database/drizzle.js").EffectSQL
 export declare const advanceEpoch: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, epochStart: number) => Effect.Effect<void, never, never>;
-export declare const reset: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
+/**
+ * Clears the fold only when a committed revert removed an update or the epoch start. Otherwise the
+ * fold still matches the surviving history, and keeping its baseline keeps the prompt cache.
+ */
+export declare const rewind: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;
-}, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<void, never, never>;
+}, sessionID: string & import("effect/Brand").Brand<"SessionID">, boundary: number) => Effect.Effect<void, never, never>;
 /** Renders the epoch baseline shown at the start of every model request. */
 export declare const initial: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
     $client: import("effect/sql/SqlClient").SqlClient;

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

@@ -52,10 +52,10 @@ export declare const baseTranscript: (input: {
     system: {
         readonly type: "text";
         readonly text: string;
+        readonly cache?: import("@opencode/ai").CacheHint | undefined;
         readonly metadata?: {
             readonly [x: string]: unknown;
         } | undefined;
-        readonly cache?: import("@opencode/ai").CacheHint | undefined;
     }[];
     messages: Message[];
 };

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

@@ -23,18 +23,15 @@ export declare const prepare: (request: {
     type: "user";
     payload: {
         readonly text: string;
-        readonly metadata?: {
-            readonly [x: string]: unknown;
-        } | undefined;
         readonly files?: readonly {
             readonly data: string;
+            readonly mime: string;
             readonly source: {
                 readonly type: "inline";
             } | {
                 readonly type: "uri";
                 readonly uri: string;
             };
-            readonly mime: string;
             readonly name?: string | undefined;
             readonly description?: string | undefined;
             readonly mention?: {
@@ -52,8 +49,8 @@ export declare const prepare: (request: {
             } | undefined;
         }[] | undefined;
         readonly skills?: readonly {
-            readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
             readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
+            readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
             readonly text?: string | undefined;
             readonly mention?: {
                 readonly start: number;
@@ -61,6 +58,9 @@ export declare const prepare: (request: {
                 readonly text: string;
             } | undefined;
         }[] | undefined;
+        readonly metadata?: {
+            readonly [x: string]: unknown;
+        } | undefined;
     };
-    delivery: "steer" | "queue";
-}, AttachmentError | SkillNotFoundError | import("../filesystem.js").DirectoryNotFoundError, FSUtil.Service | Instance.Service>;
+    delivery: "queue" | "steer";
+}, AttachmentError | import("../filesystem.js").DirectoryNotFoundError | SkillNotFoundError, FSUtil.Service | Instance.Service>;

package/dist/types/session/recent-text.d.ts

@@ -0,0 +1,11 @@
+export * as SessionRecentText from "./recent-text.js";
+import type { SessionMessage } from "./message.js";
+/**
+ * The text of the messages a summary compaction kept verbatim. History rebuilds it from `metadata.keepID`;
+ * compactions written before that reference carry the text they stored.
+ */
+export declare const kept: (message: SessionMessage.CompactionCompleted) => string;
+/** One message as the recent, verbatim part of a summary shows it. Empty for messages that part leaves out. */
+export declare const messageToText: (message: SessionMessage.Info) => string;
+export declare const truncateToolOutput: (value: string) => string;
+export declare const serializeToolContent: (content: ReadonlyArray<SessionMessage.ToolStateCompleted["content"][number]>) => string;

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

@@ -15,6 +15,6 @@ export declare const stage: (input: {
     messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
     snapshot: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
     files: readonly import("@opencode/schema/file-diff").Info[];
-}, MessageNotFoundError | import("../filesystem.js").DirectoryNotFoundError | Snapshot.Error, Database.Service | Bus.Service | Instance.Service>;
+}, import("../filesystem.js").DirectoryNotFoundError | Snapshot.Error | MessageNotFoundError, Database.Service | Bus.Service | Instance.Service>;
 export declare const clear: (session: SessionSchema.Info) => Effect.Effect<void, import("../filesystem.js").DirectoryNotFoundError | 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

@@ -22,82 +22,78 @@ export type DrainResult = Data.TaggedEnum<{
     };
 }>;
 export declare const DrainResult: {
-    readonly Complete: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Complete";
-    }, "_tag">;
-    readonly Moved: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Moved";
-        readonly continuation?: Continuation | undefined;
-    }, "_tag">;
-    readonly Reloaded: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Reloaded";
-        readonly force: boolean;
-        readonly continuation?: Continuation | undefined;
-    }, "_tag">;
     readonly $is: <Tag extends "Complete" | "Moved" | "Reloaded">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Complete";
     }, {
         readonly _tag: Tag;
     }> | Extract<{
         readonly _tag: "Moved";
-        readonly continuation?: Continuation | undefined;
+        readonly continuation?: Continuation;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
         readonly _tag: "Reloaded";
         readonly force: boolean;
-        readonly continuation?: Continuation | undefined;
+        readonly continuation?: Continuation;
     }, {
         readonly _tag: Tag;
     }>;
     readonly $match: {
-        <Cases extends {
-            readonly Complete: (args: {
-                readonly _tag: "Complete";
-            }) => any;
-            readonly Moved: (args: {
-                readonly _tag: "Moved";
-                readonly continuation?: Continuation | undefined;
-            }) => any;
-            readonly Reloaded: (args: {
-                readonly _tag: "Reloaded";
-                readonly force: boolean;
-                readonly continuation?: Continuation | undefined;
-            }) => any;
-        }>(cases: Cases): (value: {
+        <Cases extends { readonly [Tag in "Complete" | "Moved" | "Reloaded"]: (args: Extract<{
+            readonly _tag: "Complete";
+        } | {
+            readonly _tag: "Moved";
+            readonly continuation?: Continuation;
+        } | {
+            readonly _tag: "Reloaded";
+            readonly force: boolean;
+            readonly continuation?: Continuation;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
             readonly _tag: "Complete";
         } | {
             readonly _tag: "Moved";
-            readonly continuation?: Continuation | undefined;
+            readonly continuation?: Continuation;
         } | {
             readonly _tag: "Reloaded";
             readonly force: boolean;
-            readonly continuation?: Continuation | undefined;
+            readonly continuation?: Continuation;
         }) => import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Moved" | "Reloaded"]>>;
-        <Cases extends {
-            readonly Complete: (args: {
-                readonly _tag: "Complete";
-            }) => any;
-            readonly Moved: (args: {
-                readonly _tag: "Moved";
-                readonly continuation?: Continuation | undefined;
-            }) => any;
-            readonly Reloaded: (args: {
-                readonly _tag: "Reloaded";
-                readonly force: boolean;
-                readonly continuation?: Continuation | undefined;
-            }) => any;
-        }>(value: {
+        <Cases extends { readonly [Tag in "Complete" | "Moved" | "Reloaded"]: (args: Extract<{
             readonly _tag: "Complete";
         } | {
             readonly _tag: "Moved";
-            readonly continuation?: Continuation | undefined;
+            readonly continuation?: Continuation;
         } | {
             readonly _tag: "Reloaded";
             readonly force: boolean;
-            readonly continuation?: Continuation | undefined;
+            readonly continuation?: Continuation;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
+            readonly _tag: "Complete";
+        } | {
+            readonly _tag: "Moved";
+            readonly continuation?: Continuation;
+        } | {
+            readonly _tag: "Reloaded";
+            readonly force: boolean;
+            readonly continuation?: Continuation;
         }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Complete" | "Moved" | "Reloaded"]>>;
     };
+    readonly Complete: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Complete";
+    }, "_tag">;
+    readonly Moved: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Moved";
+        readonly continuation?: Continuation;
+    }, "_tag">;
+    readonly Reloaded: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Reloaded";
+        readonly force: boolean;
+        readonly continuation?: Continuation;
+    }, "_tag">;
 };
 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {

package/dist/types/session/runner/publish-llm-event.d.ts

@@ -34,7 +34,7 @@ export interface StepRecord {
             type: "step-finish";
         }>["reason"]["normalized"];
         readonly rawFinish?: string;
-        readonly providerState?: SessionMessage.ProviderState;
+        readonly native?: SessionMessage.Native;
         readonly tokens: ReturnType<typeof SessionUsage.tokens>;
     };
     readonly needsContinuation: boolean;

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

@@ -31,34 +31,8 @@ export type Outcome = Data.TaggedEnum<{
     };
 }>;
 export declare const Outcome: {
-    readonly Retry: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Retry";
-        readonly error: SessionError.Error;
-        readonly decision: SessionRunnerRetry.Decision;
-    }, "_tag">;
-    readonly Completed: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Completed";
-        readonly needsContinuation: boolean;
-    }, "_tag">;
-    readonly Continue: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "Continue";
-        readonly error: SessionError.Error;
-        readonly decision: SessionRunnerRetry.Decision;
-    }, "_tag">;
-    readonly RecoverFull: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "RecoverFull";
-    }, "_tag">;
-    readonly Compacted: Data.TaggedEnum.ConstructorFrom<{
+    readonly $is: <Tag extends "Compacted" | "Completed" | "Continue" | "OutputLimit" | "RecoverFull" | "Retry">(tag: Tag) => (u: unknown) => u is Extract<{
         readonly _tag: "Compacted";
-    }, "_tag">;
-    readonly OutputLimit: Data.TaggedEnum.ConstructorFrom<{
-        readonly _tag: "OutputLimit";
-        readonly needsContinuation: boolean;
-    }, "_tag">;
-    readonly $is: <Tag extends "Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted" | "OutputLimit">(tag: Tag) => (u: unknown) => u is Extract<{
-        readonly _tag: "Retry";
-        readonly error: SessionError.Error;
-        readonly decision: SessionRunnerRetry.Decision;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
@@ -73,49 +47,24 @@ export declare const Outcome: {
     }, {
         readonly _tag: Tag;
     }> | Extract<{
-        readonly _tag: "RecoverFull";
+        readonly _tag: "OutputLimit";
+        readonly needsContinuation: boolean;
     }, {
         readonly _tag: Tag;
     }> | Extract<{
-        readonly _tag: "Compacted";
+        readonly _tag: "RecoverFull";
     }, {
         readonly _tag: Tag;
     }> | Extract<{
-        readonly _tag: "OutputLimit";
-        readonly needsContinuation: boolean;
+        readonly _tag: "Retry";
+        readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, {
         readonly _tag: Tag;
     }>;
     readonly $match: {
-        <Cases extends {
-            readonly Retry: (args: {
-                readonly _tag: "Retry";
-                readonly error: SessionError.Error;
-                readonly decision: SessionRunnerRetry.Decision;
-            }) => any;
-            readonly Completed: (args: {
-                readonly _tag: "Completed";
-                readonly needsContinuation: boolean;
-            }) => any;
-            readonly Continue: (args: {
-                readonly _tag: "Continue";
-                readonly error: SessionError.Error;
-                readonly decision: SessionRunnerRetry.Decision;
-            }) => any;
-            readonly RecoverFull: (args: {
-                readonly _tag: "RecoverFull";
-            }) => any;
-            readonly Compacted: (args: {
-                readonly _tag: "Compacted";
-            }) => any;
-            readonly OutputLimit: (args: {
-                readonly _tag: "OutputLimit";
-                readonly needsContinuation: boolean;
-            }) => any;
-        }>(cases: Cases): (value: {
-            readonly _tag: "Retry";
-            readonly error: SessionError.Error;
-            readonly decision: SessionRunnerRetry.Decision;
+        <Cases extends { readonly [Tag in "Compacted" | "Completed" | "Continue" | "OutputLimit" | "RecoverFull" | "Retry"]: (args: Extract<{
+            readonly _tag: "Compacted";
         } | {
             readonly _tag: "Completed";
             readonly needsContinuation: boolean;
@@ -123,43 +72,38 @@ export declare const Outcome: {
             readonly _tag: "Continue";
             readonly error: SessionError.Error;
             readonly decision: SessionRunnerRetry.Decision;
+        } | {
+            readonly _tag: "OutputLimit";
+            readonly needsContinuation: boolean;
         } | {
             readonly _tag: "RecoverFull";
         } | {
+            readonly _tag: "Retry";
+            readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(cases: Cases): (value: {
             readonly _tag: "Compacted";
+        } | {
+            readonly _tag: "Completed";
+            readonly needsContinuation: boolean;
+        } | {
+            readonly _tag: "Continue";
+            readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "OutputLimit";
             readonly needsContinuation: boolean;
-        }) => import("effect/Unify").Unify<ReturnType<Cases["Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted" | "OutputLimit"]>>;
-        <Cases extends {
-            readonly Retry: (args: {
-                readonly _tag: "Retry";
-                readonly error: SessionError.Error;
-                readonly decision: SessionRunnerRetry.Decision;
-            }) => any;
-            readonly Completed: (args: {
-                readonly _tag: "Completed";
-                readonly needsContinuation: boolean;
-            }) => any;
-            readonly Continue: (args: {
-                readonly _tag: "Continue";
-                readonly error: SessionError.Error;
-                readonly decision: SessionRunnerRetry.Decision;
-            }) => any;
-            readonly RecoverFull: (args: {
-                readonly _tag: "RecoverFull";
-            }) => any;
-            readonly Compacted: (args: {
-                readonly _tag: "Compacted";
-            }) => any;
-            readonly OutputLimit: (args: {
-                readonly _tag: "OutputLimit";
-                readonly needsContinuation: boolean;
-            }) => any;
-        }>(value: {
+        } | {
+            readonly _tag: "RecoverFull";
+        } | {
             readonly _tag: "Retry";
             readonly error: SessionError.Error;
             readonly decision: SessionRunnerRetry.Decision;
+        }) => import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Completed" | "Continue" | "OutputLimit" | "RecoverFull" | "Retry"]>>;
+        <Cases extends { readonly [Tag in "Compacted" | "Completed" | "Continue" | "OutputLimit" | "RecoverFull" | "Retry"]: (args: Extract<{
+            readonly _tag: "Compacted";
         } | {
             readonly _tag: "Completed";
             readonly needsContinuation: boolean;
@@ -167,15 +111,61 @@ export declare const Outcome: {
             readonly _tag: "Continue";
             readonly error: SessionError.Error;
             readonly decision: SessionRunnerRetry.Decision;
+        } | {
+            readonly _tag: "OutputLimit";
+            readonly needsContinuation: boolean;
         } | {
             readonly _tag: "RecoverFull";
         } | {
+            readonly _tag: "Retry";
+            readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
+        }, {
+            readonly _tag: Tag;
+        }>) => any; }>(value: {
             readonly _tag: "Compacted";
+        } | {
+            readonly _tag: "Completed";
+            readonly needsContinuation: boolean;
+        } | {
+            readonly _tag: "Continue";
+            readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
         } | {
             readonly _tag: "OutputLimit";
             readonly needsContinuation: boolean;
-        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Retry" | "Completed" | "Continue" | "RecoverFull" | "Compacted" | "OutputLimit"]>>;
+        } | {
+            readonly _tag: "RecoverFull";
+        } | {
+            readonly _tag: "Retry";
+            readonly error: SessionError.Error;
+            readonly decision: SessionRunnerRetry.Decision;
+        }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Compacted" | "Completed" | "Continue" | "OutputLimit" | "RecoverFull" | "Retry"]>>;
     };
+    readonly Compacted: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Compacted";
+    }, "_tag">;
+    readonly Completed: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Completed";
+        readonly needsContinuation: boolean;
+    }, "_tag">;
+    readonly Continue: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Continue";
+        readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
+    }, "_tag">;
+    readonly OutputLimit: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "OutputLimit";
+        readonly needsContinuation: boolean;
+    }, "_tag">;
+    readonly RecoverFull: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "RecoverFull";
+    }, "_tag">;
+    readonly Retry: Data.TaggedEnum.ConstructorFrom<{
+        readonly _tag: "Retry";
+        readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
+    }, "_tag">;
 };
 interface Input {
     readonly isLocationClosed: () => boolean;
@@ -194,9 +184,7 @@ interface Input {
 /** Captures Location-scoped dependencies without introducing another service or execution loop. */
 export declare const make: Effect.Effect<{
     attempt: (input: Input) => Effect.Effect<{
-        readonly _tag: "Retry";
-        readonly error: SessionError.Error;
-        readonly decision: SessionRunnerRetry.Decision;
+        readonly _tag: "Compacted";
     } | {
         readonly _tag: "Completed";
         readonly needsContinuation: boolean;
@@ -204,12 +192,14 @@ export declare const make: Effect.Effect<{
         readonly _tag: "Continue";
         readonly error: SessionError.Error;
         readonly decision: SessionRunnerRetry.Decision;
-    } | {
-        readonly _tag: "RecoverFull";
-    } | {
-        readonly _tag: "Compacted";
     } | {
         readonly _tag: "OutputLimit";
         readonly needsContinuation: boolean;
+    } | {
+        readonly _tag: "RecoverFull";
+    } | {
+        readonly _tag: "Retry";
+        readonly error: SessionError.Error;
+        readonly decision: SessionRunnerRetry.Decision;
     }, AIError | StepFailedError, never>;
-}, never, Bus.Service | import("@opencode/ai").LLMClientService | Snapshot.Service | ToolOutput.Service>;
+}, never, import("@opencode/ai").LLMClientService | Bus.Service | Snapshot.Service | ToolOutput.Service>;