@opencode/schema 2.0.32 → 2.1.1

package/dist/session-transfer.d.ts

@@ -186,9 +186,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("./event.js").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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -197,7 +206,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">;
@@ -267,6 +275,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -275,7 +284,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">;
@@ -328,6 +336,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -336,7 +345,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;
@@ -361,15 +369,15 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("./prompt.js").FileAttachment) => {
                 readonly data: string;
+                readonly mime: string;
                 readonly source: {
                     readonly type: "inline";
                 } | {
                     readonly type: "uri";
                     readonly uri: string;
                 };
-                readonly mime: string;
-                readonly description?: string | undefined;
                 readonly name?: string | undefined;
+                readonly description?: string | undefined;
                 readonly mention?: {
                     readonly start: number;
                     readonly end: number;
@@ -399,15 +407,15 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("./prompt.js").FileAttachment) => {
                 readonly data: string;
+                readonly mime: string;
                 readonly source: {
                     readonly type: "inline";
                 } | {
                     readonly type: "uri";
                     readonly uri: string;
                 };
-                readonly mime: string;
-                readonly description?: string | undefined;
                 readonly name?: string | undefined;
+                readonly description?: string | undefined;
                 readonly mention?: {
                     readonly start: number;
                     readonly end: number;
@@ -466,6 +474,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -474,10 +483,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -486,10 +495,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -498,20 +507,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("./event.js").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">;
@@ -535,12 +540,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("./event.js").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<{
@@ -569,11 +574,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>;
@@ -586,8 +591,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;
@@ -657,7 +661,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"> & {
@@ -731,16 +735,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("./event.js").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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -750,7 +758,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"> & {
@@ -820,56 +827,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -879,7 +839,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"> & {
@@ -914,6 +873,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("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -922,8 +882,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<{
@@ -945,13 +903,5 @@ 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("./event.js").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>;
-        }>;
     }>]>>;
 }>;

package/dist/session.d.ts

@@ -1,5 +1,5 @@
 export * as Session from "./session.js";
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
 import { SessionMetadata } from "./session-metadata.js";
@@ -224,3 +224,111 @@ export declare const ListAnchor: Schema.Struct<{
 }>;
 export interface ListAnchor extends Schema.Schema.Type<typeof ListAnchor> {
 }
+export declare const ListFilter: Schema.Struct<{
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly archived: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
+    readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
+    readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    }>;
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
+}>;
+export interface ListFilter extends Schema.Schema.Type<typeof ListFilter> {
+}
+declare const ListCursorInput: Schema.Union<readonly [Schema.Struct<{
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly archived: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly anchor: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>;
+}>, Schema.Struct<{
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly archived: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
+    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 anchor: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>;
+}>, Schema.Struct<{
+    readonly order: Schema.optional<Schema.Literals<readonly ["asc", "desc"]>>;
+    readonly search: Schema.optional<Schema.String>;
+    readonly parentID: Schema.optional<Schema.Union<readonly [Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
+    readonly archived: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
+    readonly anchor: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly time: Schema.Finite;
+        readonly direction: Schema.Literals<readonly ["previous", "next"]>;
+    }>;
+}>]>;
+export declare const ListCursor: Schema.brand<Schema.String, "SessionsCursor"> & {
+    make: (input: typeof ListCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
+    parse: (input: string) => Effect.Effect<{
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly archived?: boolean | undefined;
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "next" | "previous";
+        };
+    } | {
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly archived?: boolean | undefined;
+        readonly project: string & import("effect/Brand").Brand<"Project.ID">;
+        readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "next" | "previous";
+        };
+    } | {
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly archived?: boolean | undefined;
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "next" | "previous";
+        };
+    }, "Invalid cursor", never>;
+};
+export type ListCursor = typeof ListCursor.Type;

package/dist/session.js

@@ -1,10 +1,11 @@
 export * as Session from "./session.js";
-import { Schema } from "effect";
+import { Effect, Result, Schema, SchemaGetter, SchemaParser } from "effect";
+import { Base64Url } from "effect/encoding";
 import { Agent } from "./agent.js";
 import { Location } from "./location.js";
 import { Model } from "./model.js";
 import { Project } from "./project.js";
-import { DateTimeUtcFromMillis, optional, RelativePath } from "./schema.js";
+import { AbsolutePath, DateTimeUtcFromMillis, optional, RelativePath, statics } from "./schema.js";
 import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
 import { SessionMetadata } from "./session-metadata.js";
@@ -52,3 +53,64 @@ export const ListAnchor = Schema.Struct({
     time: Schema.Finite,
     direction: Schema.Literals(["previous", "next"]),
 }).annotate({ identifier: "Session.ListAnchor" });
+// These fields are also the session.list HTTP query parameters. Raw Schema.optional keeps that
+// endpoint's OpenAPI parameters unchanged.
+const ListFilterFields = {
+    order: Schema.Literals(["asc", "desc"]).pipe(Schema.optional).annotate({
+        description: "Session order for the first page. Use desc for newest first or asc for oldest first.",
+    }),
+    search: Schema.String.pipe(Schema.optional),
+    parentID: Schema.Union([
+        ID,
+        Schema.Null.pipe(Schema.encodeTo(Schema.Literal("null"), {
+            decode: SchemaGetter.transform(() => null),
+            encode: SchemaGetter.transform(() => "null"),
+        })),
+    ])
+        .annotate({ description: "Filter by parent session. Use null to return only root sessions." })
+        .pipe(Schema.optional),
+    archived: Schema.Literals(["true", "false"])
+        .pipe(Schema.decodeTo(Schema.Boolean, {
+        decode: SchemaGetter.transform((value) => value === "true"),
+        encode: SchemaGetter.transform((value) => (value ? "true" : "false")),
+    }))
+        .annotate({
+        description: "Filter by archive state. Use true to return only archived sessions or false to exclude them. Omit to include both.",
+    })
+        .pipe(Schema.optional),
+};
+export const ListFilter = Schema.Struct({
+    ...ListFilterFields,
+    directory: AbsolutePath.pipe(Schema.optional),
+    project: Project.ID.pipe(Schema.optional),
+    subpath: RelativePath.pipe(Schema.optional),
+}).annotate({ identifier: "Session.ListFilter" });
+const ListCursorInput = Schema.Union([
+    Schema.Struct({ ...ListFilterFields, directory: AbsolutePath, anchor: ListAnchor }),
+    Schema.Struct({
+        ...ListFilterFields,
+        project: Project.ID,
+        subpath: RelativePath.pipe(Schema.optional),
+        anchor: ListAnchor,
+    }),
+    Schema.Struct({ ...ListFilterFields, anchor: ListAnchor }),
+]);
+const ListCursorJson = Schema.fromJsonString(ListCursorInput);
+const encodeListCursor = Schema.encodeSync(ListCursorJson);
+const decodeListCursor = Schema.decodeUnknownEffect(ListCursorJson);
+export const ListCursor = Schema.String.pipe(Schema.brand("SessionsCursor"), Schema.annotate({
+    identifier: "SessionsCursor",
+    description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
+}), statics((schema) => {
+    // Read the default constructor without caching it on the schema, so `make` can be replaced.
+    const make = SchemaParser.make(schema);
+    return {
+        make: (input) => make(Base64Url.encode(encodeListCursor(input))),
+        parse: (input) => Effect.suspend(() => {
+            const result = Base64Url.decodeString(input);
+            return Result.isFailure(result)
+                ? Effect.fail("Invalid cursor")
+                : decodeListCursor(result.success).pipe(Effect.mapError(() => "Invalid cursor"));
+        }),
+    };
+}));

package/dist/v1/permission.d.ts

@@ -51,14 +51,6 @@ export declare const Approval: Schema.Struct<{
 }>;
 export type Approval = typeof Approval.Type;
 export declare const AskInput: Schema.Struct<{
-    readonly id: Schema.optional<Schema.brand<Schema.String, "PermissionV1.ID"> & {
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
-    }>;
-    readonly ruleset: Schema.$Array<Schema.Struct<{
-        readonly permission: Schema.String;
-        readonly pattern: Schema.String;
-        readonly action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
-    }>>;
     readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -71,6 +63,14 @@ export declare const AskInput: Schema.Struct<{
         readonly messageID: Schema.String;
         readonly callID: Schema.String;
     }>>;
+    readonly id: Schema.optional<Schema.brand<Schema.String, "PermissionV1.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+    }>;
+    readonly ruleset: Schema.$Array<Schema.Struct<{
+        readonly permission: Schema.String;
+        readonly pattern: Schema.String;
+        readonly action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
 }>;
 export type AskInput = typeof AskInput.Type;
 export declare const ReplyInput: Schema.Struct<{