npm - @opencode/core - Versions diffs - 2.0.32 → 2.1.1 - Mend

@opencode/core 2.0.32 → 2.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (918) hide show

package/dist/types/session/subagent-completion.d.ts CHANGED Viewed

@@ -5,7 +5,7 @@ import type { Session } from "../session.js";
 import type { SessionMessage } from "./message.js";
 export declare const NO_TEXT = "Subagent completed without a text response.";
 export declare function text(message: SessionMessage.Info | undefined): string;
-export declare const deliver: (sessions: Pick<Session.Interface, "synthetic">, jobs: Pick<Job.Interface, "completeBackground">, input: Pick<Job.Info, "status" | "output" | "error" | "notificationID"> & {
+export declare const deliver: (sessions: Pick<Session.Interface, "synthetic">, jobs: Pick<Job.Interface, "completeBackground">, input: Pick<Job.Info, "error" | "notificationID" | "output" | "status"> & {
     recovery: Extract<Job.Recovery, {
         kind: "subagent";
     }>;

package/dist/types/session/title.d.ts CHANGED Viewed

@@ -13,5 +13,5 @@ declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionTitl
 export declare class Service extends Service_base {
 }
 export declare const isUntitled: (session: SessionSchema.Info) => boolean;
-export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService | SessionStore.Service | SessionContext.Service>;
+export declare const layer: Layer.Layer<Service, never, import("@opencode/ai").LLMClientService | Database.Service | Bus.Service | SessionStore.Service | SessionContext.Service>;
 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/transfer.d.ts CHANGED Viewed

@@ -187,9 +187,18 @@ export declare const Data: Schema.Struct<{
         }>>, never, never>;
     }>;
     readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly id: 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">;
+        };
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
         readonly type: Schema.tag<"agent-switched">;
         readonly agent: Schema.brand<Schema.String, "Agent.ID">;
         readonly previous: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Agent.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Agent.ID">>, never, never>;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -198,7 +207,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"model-switched">;
         readonly model: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Model.ID">;
@@ -268,6 +276,7 @@ export declare const Data: Schema.Struct<{
                 readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
             };
         }>, never, never>;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -276,7 +285,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"location-switched">;
         readonly location: Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -329,6 +337,7 @@ export declare const Data: Schema.Struct<{
             }>, never, never>;
             readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
         }>>, never, never>;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -337,7 +346,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly text: Schema.String;
         readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
             readonly data: Schema.String;
@@ -362,13 +370,13 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 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?: {
@@ -400,13 +408,13 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 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?: {
@@ -467,6 +475,7 @@ export declare const Data: Schema.Struct<{
             }>>, never, never>;
         }>>>, never, never>;
         readonly type: Schema.tag<"user">;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -475,10 +484,10 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly text: Schema.String;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly type: Schema.tag<"synthetic">;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -487,10 +496,10 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"system">;
         readonly text: Schema.String;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -499,20 +508,16 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"skill">;
         readonly skill: Schema.brand<Schema.String, "Skill.ID">;
         readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly text: Schema.String;
+    }>, Schema.Struct<{
         readonly id: 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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly time: Schema.Struct<{
-            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"shell">;
         readonly shellID: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -536,12 +541,12 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         }>;
+    }>, Schema.Struct<{
         readonly id: 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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"assistant">;
         readonly agent: Schema.brand<Schema.String, "Agent.ID">;
         readonly model: Schema.Struct<{
@@ -570,11 +575,11 @@ export declare const Data: Schema.Struct<{
         readonly content: Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
             readonly type: Schema.tag<"text">;
             readonly text: Schema.String;
-            readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"reasoning">;
             readonly text: Schema.String;
-            readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
             readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
                 readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
                 readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
@@ -587,8 +592,7 @@ export declare const Data: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
             readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-            readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
             readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
                 readonly status: Schema.tag<"streaming">;
                 readonly input: Schema.String;
@@ -658,7 +662,7 @@ export declare const Data: Schema.Struct<{
         }>>, never, never>;
         readonly finish: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>>>, Schema.optionalKey<Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>>, never, never>;
         readonly rawFinish: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -732,16 +736,20 @@ export declare const Data: Schema.Struct<{
             readonly streamed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         }>;
+    }>, Schema.Union<readonly [Schema.Struct<{
         readonly id: 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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    }>, Schema.Union<readonly [Schema.Struct<{
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+        readonly type: Schema.tag<"compaction">;
         readonly status: Schema.tag<"running">;
         readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
         readonly summary: Schema.String;
-        readonly recent: Schema.String;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -751,7 +759,6 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
         readonly type: Schema.tag<"compaction">;
-    }>, Schema.Struct<{
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -821,56 +828,9 @@ export declare const Data: Schema.Struct<{
                 readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
             };
         }>, never, never>;
-        readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly summary: Schema.String;
-        readonly recent: Schema.String;
-        readonly providerContext: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly version: Schema.Literal<1>;
-            readonly provenance: Schema.Struct<{
-                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 provider: Schema.String;
-                readonly modelID: Schema.String;
-                readonly route: Schema.String;
-                readonly protocol: Schema.String;
-                readonly endpoint: Schema.String;
-            }>;
-            readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly version: Schema.Literal<1>;
-            readonly provenance: Schema.Struct<{
-                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 provider: Schema.String;
-                readonly modelID: Schema.String;
-                readonly route: Schema.String;
-                readonly protocol: Schema.String;
-                readonly endpoint: Schema.String;
-            }>;
-            readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>, never, never>;
+    }>, Schema.Struct<{
         readonly id: 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">;
@@ -880,7 +840,6 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
         readonly type: Schema.tag<"compaction">;
-    }>, Schema.Struct<{
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -915,6 +874,7 @@ export declare const Data: Schema.Struct<{
                 readonly body: Schema.String;
             }>>, never, never>;
         }>;
+    }>]>, Schema.Struct<{
         readonly id: 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">;
@@ -923,8 +883,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-        readonly type: Schema.tag<"compaction">;
-    }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
         readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
@@ -946,14 +904,6 @@ export declare const Data: Schema.Struct<{
                 readonly body: Schema.String;
             }>>, never, never>;
         }>>, never, never>;
-        readonly id: 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">;
-        };
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly time: Schema.Struct<{
-            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        }>;
     }>]>>;
 }>;
 export type Data = SessionTransfer.Data;

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

@@ -1,7 +1,7 @@
 export * as Session from "./session.js";
 export * from "./session/schema.js";
 import { Effect, Schema, Context, Stream } from "effect";
-import { ListAnchor } from "@opencode/schema/session";
+import { ListAnchor, ListCursor, ListFilter } from "@opencode/schema/session";
 import { Model } from "@opencode/schema/model";
 import { Location } from "./location.js";
 import type { FileSystem } from "./filesystem.js";
@@ -12,7 +12,7 @@ import { Agent } from "@opencode/schema/agent";
 import type { Permission } from "@opencode/schema/permission";
 import { SessionRunner } from "./session/runner/index.js";
 import { SessionStore } from "./session/store.js";
-import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } from "./session/error.js";
+import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } from "./session/error.js";
 import { Node } from "@opencode/util/effect/app-node";
 import { LayerNode } from "@opencode/util/effect/layer-node";
 import { SessionEvent } from "./session/event.js";
@@ -26,9 +26,8 @@ import type { EventLog } from "@opencode/schema/event-log";
 import type { FileDiff } from "@opencode/schema/file-diff";
 import type { Command } from "./command.js";
 import { SessionEnvironment } from "./session/environment.js";
-export { ListAnchor };
+export { ListAnchor, ListCursor };
 export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -40,6 +39,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -48,11 +48,8 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
     }>>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>, Schema.Struct<{
-    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
     readonly workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
         create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -64,6 +61,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -72,6 +70,10 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
     }>>;
+    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
 }>, Schema.Struct<{
     workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -84,6 +86,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    archived: Schema.optional<Schema.Boolean>;
     anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -116,7 +119,7 @@ type ForkInput = {
     sessionID: SessionSchema.ID;
     before?: SessionMessage.ID;
 };
-export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
+export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
 type InboxItemRef = {
     readonly sessionID: SessionSchema.ID;
     readonly inboxID: SessionMessage.ID;
@@ -124,9 +127,17 @@ type InboxItemRef = {
 export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError };
 export { TurnRangeError };
 export interface Interface {
-    readonly list: (input?: ListInput) => Effect.Effect<{
+    /** A cursor carries the filters of the request that produced it, so filters passed with a cursor are ignored. */
+    readonly list: (input?: ListFilter & {
+        readonly limit?: number;
+        readonly cursor?: ListCursor;
+    }) => Effect.Effect<{
         readonly data: SessionSchema.Info[];
-    }>;
+        readonly cursor: {
+            readonly previous?: ListCursor;
+            readonly next?: ListCursor;
+        };
+    }, InvalidListCursorError>;
     readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info, NotFoundError>;
     readonly fork: (input: ForkInput) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>;
     readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>;
@@ -185,6 +196,8 @@ export interface Interface {
         sessionID: SessionSchema.ID;
         title: string;
     }) => Effect.Effect<void, NotFoundError>;
+    readonly archive: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly unarchive: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
     readonly setMetadata: (input: {
         sessionID: SessionSchema.ID;
         metadata: SessionSchema.Metadata;

package/dist/types/shell/result.d.ts CHANGED Viewed

@@ -18,10 +18,10 @@ export declare const unavailable: Shell.Output;
 export declare function output(result: Result): Output;
 export declare function notice(output: Pick<Output, "exit" | "signal" | "timeout">): string | undefined;
 export declare function metadata(output: Output): {
-    timeout?: boolean | undefined;
-    signal?: string | undefined;
-    exit?: number | undefined;
     truncated: boolean;
+    exit?: number | undefined;
+    signal?: string | undefined;
+    timeout?: boolean | undefined;
 };
 export declare function notification(input: {
     shellID: string;
@@ -33,26 +33,26 @@ export declare function notification(input: {
 }): {
     text: string;
     metadata: {
-        timeout?: boolean | undefined;
-        signal?: string | undefined;
-        exit?: number | undefined;
         truncated?: boolean | undefined;
-        state: "cancelled" | "error" | "completed";
-        jobID?: string | undefined;
+        exit?: number | undefined;
+        signal?: string | undefined;
+        timeout?: boolean | undefined;
         source: string;
         shellID: string;
+        jobID?: string | undefined;
+        state: "cancelled" | "completed" | "error";
     };
 };
 export declare function userNotification(result: Result): {
-    text: string;
     metadata: {
-        timeout?: boolean | undefined;
-        signal?: string | undefined;
-        exit?: number | undefined;
         truncated?: boolean | undefined;
-        state: "cancelled" | "error" | "completed";
-        jobID?: string | undefined;
+        exit?: number | undefined;
+        signal?: string | undefined;
+        timeout?: boolean | undefined;
         source: string;
         shellID: string;
+        jobID?: string | undefined;
+        state: "cancelled" | "completed" | "error";
     };
+    text: string;
 };

package/dist/types/skill.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 export * as Skill from "./skill.js";
-import type { FSUtil } from "@opencode/util/fs-util";
+import { FSUtil } from "@opencode/util/fs-util";
 import { Context, Effect, Types } from "effect";
 import { Skill } from "@opencode/schema/skill";
 import { Permission } from "./permission.js";

package/dist/types/state.d.ts CHANGED Viewed

@@ -49,7 +49,7 @@ export declare function shutdown<A, E, R>(effect: Effect.Effect<A, E, R>): Effec
  * queued behind the layer's locks is interrupted with the layer. That interruption is not a failure.
  */
 export declare function reconcile(root: Scope.Scope, fork: (effect: Effect.Effect<void>) => Fiber.Fiber<void>, work: () => Effect.Effect<void>): Effect.Effect<void>;
-export declare const inherit: () => Effect.Effect<(<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>), never, never>;
+export declare const inherit: () => Effect.Effect<<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>, never, never>;
 export interface Options<State, Editor> {
     readonly name?: string;
     /** Creates the empty base value for every rebuild. */

package/dist/types/tool/plugin/read.d.ts CHANGED Viewed

@@ -22,11 +22,11 @@ declare const Output: Schema.Union<readonly [Schema.Struct<{
 }>, typeof ReadToolFileSystem.TextPage, typeof ReadToolFileSystem.ListPage]>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | FileAccess.Service | ReadToolFileSystem.Service | SessionInstructions.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | FileAccess.Service | SessionInstructions.Service | ReadToolFileSystem.Service>;
 };
 export declare const toModelContent: (path: string, offset: number | undefined, output: typeof Output.Type) => string | readonly [{
     readonly type: "text";
-    readonly text: "PDF read successfully" | "Image read successfully";
+    readonly text: "Image read successfully" | "PDF read successfully";
 }, {
     readonly type: "file";
     readonly uri: `data:${string};base64,${string}`;

package/dist/types/tool/plugin/shell.d.ts CHANGED Viewed

@@ -19,5 +19,5 @@ export declare const Input: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Job.Service | Session.Service | Shell.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Job.Service | Shell.Service | Session.Service>;
 };

package/dist/types/tool/plugin/skill.d.ts CHANGED Viewed

@@ -14,7 +14,7 @@ export declare const Output: Schema.Struct<{
     readonly output: Schema.String;
 }>;
 export declare const description: string;
-export declare const toModelOutput: (skill: Skill.Info, files: ReadonlyArray<string>) => string;
+export declare const toModelOutput: typeof Skill.toModelOutput;
 export declare const Plugin: {
     id: string;
     effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Permission.Service | Skill.Service>;

package/dist/types/tool/plugin/todo.d.ts ADDED Viewed

@@ -0,0 +1,29 @@
+export * as TodoTool from "./todo.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Config } from "../../config.js";
+import { Permission } from "../../permission.js";
+export declare const name = "todowrite";
+export declare const Info: Schema.Struct<{
+    readonly content: Schema.String;
+    readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Input: Schema.Struct<{
+    readonly todos: Schema.$Array<Schema.Struct<{
+        readonly content: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+    }>>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly todos: Schema.$Array<Schema.Struct<{
+        readonly content: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+    }>>;
+}>;
+export type Output = typeof Output.Type;
+export declare const summarize: (todos: ReadonlyArray<Info>) => string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Config.Service | Permission.Service>;
+};

package/dist/types/tool/plugin/webfetch.d.ts CHANGED Viewed

@@ -16,7 +16,7 @@ export declare const Input: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | HttpClient.HttpClient | Permission.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, HttpClient.HttpClient | import("effect/Scope").Scope | Permission.Service>;
 };
 export declare function extractTextFromHTML(html: string): string;
 export { convertHTMLToMarkdown };

package/dist/types/tool/read-filesystem.d.ts CHANGED Viewed

@@ -83,10 +83,10 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/ReadToolFileSystem", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const read: (files: Environment.Files, input: string & import("effect/Brand").Brand<"AbsolutePath">, resource: string, page?: {
-    readonly limit?: number | undefined;
+export declare const read: (files: Files, input: string & import("effect/Brand").Brand<"AbsolutePath">, resource: string, page?: {
     readonly offset?: number | undefined;
-} | undefined) => Effect.Effect<TextPage | ListPage | {
+    readonly limit?: number | undefined;
+} | undefined) => Effect.Effect<ListPage | TextPage | {
     type: "file";
     uri: string;
     name: string;
@@ -100,5 +100,5 @@ export declare const read: (files: Environment.Files, input: string & import("ef
     content: string;
     encoding: "utf8";
     mime: string;
-}, Environment.NotFound | Environment.Failed | BinaryFileError | MediaIngestLimitError | OffsetOutOfRangeError | PathKindError, never>;
+}, BinaryFileError | Environment.Failed | MediaIngestLimitError | Environment.NotFound | OffsetOutOfRangeError | PathKindError, never>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;