@opencode/schema 0.0.0-dev-21086 → 0.0.0-dev-21091

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,104 @@ export declare const ListAnchor: Schema.Struct<{
 }>;
 export interface ListAnchor extends Schema.Schema.Type<typeof ListAnchor> {
 }
+export declare const ListFilter: Schema.Struct<{
+    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">>;
+    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>]>>;
+}>;
+export interface ListFilter extends Schema.Schema.Type<typeof ListFilter> {
+}
+declare const ListCursorInput: Schema.Union<readonly [Schema.Struct<{
+    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"]>;
+    }>;
+    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>]>>;
+}>, 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 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"]>;
+    }>;
+    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>]>>;
+}>, Schema.Struct<{
+    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"]>;
+    }>;
+    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>]>>;
+}>]>;
+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 directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "previous" | "next";
+        };
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+    } | {
+        readonly project: string & import("effect/Brand").Brand<"Project.ID">;
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "previous" | "next";
+        };
+        readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+    } | {
+        readonly anchor: {
+            readonly id: string & import("effect/Brand").Brand<"SessionID">;
+            readonly time: number;
+            readonly direction: "previous" | "next";
+        };
+        readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
+        readonly order?: "asc" | "desc" | undefined;
+        readonly search?: string | undefined;
+    }, "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,55 @@ 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),
+};
+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/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "0.0.0-dev-21086",
+  "version": "0.0.0-dev-21091",
   "type": "module",
   "license": "MIT",
   "repository": {