@opencode-ai/schema 0.0.0-next-14855 → 0.0.0-reserved.0

package/dist/session-message.js

@@ -1,175 +0,0 @@
-export * as SessionMessage from "./session-message.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ProviderMetadata, ToolContent } from "./llm.js";
-import { Model } from "./model.js";
-import { FileAttachment, Prompt } from "./prompt.js";
-import { DateTimeUtcFromMillis, RelativePath, statics } from "./schema.js";
-import { SessionID } from "./session-id.js";
-import { ascending } from "./identifier.js";
-import { Event } from "./event.js";
-import { Shell as ShellSchema } from "./shell.js";
-export const ID = Schema.String.check(Schema.isStartsWith("msg_")).pipe(Schema.brand("Session.Message.ID"), statics((schema) => ({
-    create: () => schema.make("msg_" + ascending()),
-    fromEvent: (eventID) => schema.make(eventID.replace(/^evt_/, "msg_")),
-})));
-export const UnknownError = Schema.Struct({
-    type: Schema.Literal("unknown"),
-    message: Schema.String,
-}).annotate({ identifier: "Session.Error.Unknown" });
-const Base = {
-    id: ID,
-    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
-    time: Schema.Struct({ created: DateTimeUtcFromMillis }),
-};
-export const AgentSelected = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("agent-switched"),
-    agent: Schema.String,
-}).annotate({ identifier: "Session.Message.AgentSelected" });
-export const ModelSelected = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("model-switched"),
-    model: Model.Ref,
-}).annotate({ identifier: "Session.Message.ModelSelected" });
-export const User = Schema.Struct({
-    ...Base,
-    text: Prompt.fields.text,
-    files: Prompt.fields.files,
-    agents: Prompt.fields.agents,
-    type: Schema.Literal("user"),
-}).annotate({ identifier: "Session.Message.User" });
-export const Synthetic = Schema.Struct({
-    ...Base,
-    sessionID: SessionID,
-    text: Schema.String,
-    description: Schema.String.pipe(optional),
-    type: Schema.Literal("synthetic"),
-}).annotate({ identifier: "Session.Message.Synthetic" });
-export const System = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("system"),
-    text: Schema.String,
-}).annotate({ identifier: "Session.Message.System" });
-export const Skill = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("skill"),
-    name: Schema.String,
-    text: Schema.String,
-}).annotate({ identifier: "Session.Message.Skill" });
-export const Shell = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("shell"),
-    shell: ShellSchema.Info,
-    output: ShellSchema.Output.pipe(optional),
-    time: Schema.Struct({
-        created: DateTimeUtcFromMillis,
-        completed: DateTimeUtcFromMillis.pipe(optional),
-    }),
-}).annotate({ identifier: "Session.Message.Shell" });
-export const ToolStatePending = Schema.Struct({
-    status: Schema.Literal("pending"),
-    input: Schema.String,
-}).annotate({ identifier: "Session.Message.ToolState.Pending" });
-export const ToolStateRunning = Schema.Struct({
-    status: Schema.Literal("running"),
-    input: Schema.Record(Schema.String, Schema.Unknown),
-    structured: Schema.Record(Schema.String, Schema.Unknown),
-    content: ToolContent.pipe(Schema.Array),
-}).annotate({ identifier: "Session.Message.ToolState.Running" });
-export const ToolStateCompleted = Schema.Struct({
-    status: Schema.Literal("completed"),
-    input: Schema.Record(Schema.String, Schema.Unknown),
-    attachments: FileAttachment.pipe(Schema.Array, optional),
-    content: ToolContent.pipe(Schema.Array),
-    outputPaths: Schema.Array(Schema.String).pipe(optional),
-    structured: Schema.Record(Schema.String, Schema.Unknown),
-    result: Schema.Unknown.pipe(optional),
-}).annotate({ identifier: "Session.Message.ToolState.Completed" });
-export const ToolStateError = Schema.Struct({
-    status: Schema.Literal("error"),
-    input: Schema.Record(Schema.String, Schema.Unknown),
-    content: ToolContent.pipe(Schema.Array),
-    structured: Schema.Record(Schema.String, Schema.Unknown),
-    error: UnknownError,
-    result: Schema.Unknown.pipe(optional),
-}).annotate({ identifier: "Session.Message.ToolState.Error" });
-export const ToolState = Schema.Union([ToolStatePending, ToolStateRunning, ToolStateCompleted, ToolStateError]).pipe(Schema.toTaggedUnion("status"));
-export const AssistantTool = Schema.Struct({
-    type: Schema.Literal("tool"),
-    id: Schema.String,
-    name: Schema.String,
-    provider: Schema.Struct({
-        executed: Schema.Boolean,
-        metadata: ProviderMetadata.pipe(optional),
-        resultMetadata: ProviderMetadata.pipe(optional),
-    }).pipe(optional),
-    state: ToolState,
-    time: Schema.Struct({
-        created: DateTimeUtcFromMillis,
-        ran: DateTimeUtcFromMillis.pipe(optional),
-        completed: DateTimeUtcFromMillis.pipe(optional),
-        pruned: DateTimeUtcFromMillis.pipe(optional),
-    }),
-}).annotate({ identifier: "Session.Message.Assistant.Tool" });
-export const AssistantText = Schema.Struct({
-    type: Schema.Literal("text"),
-    id: Schema.String,
-    text: Schema.String,
-}).annotate({ identifier: "Session.Message.Assistant.Text" });
-export const AssistantReasoning = Schema.Struct({
-    type: Schema.Literal("reasoning"),
-    id: Schema.String,
-    text: Schema.String,
-    providerMetadata: ProviderMetadata.pipe(optional),
-    time: Schema.Struct({
-        created: DateTimeUtcFromMillis,
-        completed: DateTimeUtcFromMillis.pipe(optional),
-    }).pipe(optional),
-}).annotate({ identifier: "Session.Message.Assistant.Reasoning" });
-export const AssistantContent = Schema.Union([AssistantText, AssistantReasoning, AssistantTool]).pipe(Schema.toTaggedUnion("type"));
-export const Assistant = Schema.Struct({
-    ...Base,
-    type: Schema.Literal("assistant"),
-    agent: Schema.String,
-    model: Model.Ref,
-    content: AssistantContent.pipe(Schema.Array),
-    snapshot: Schema.Struct({
-        start: Schema.String.pipe(optional),
-        end: Schema.String.pipe(optional),
-        files: Schema.Array(RelativePath).pipe(optional),
-    }).pipe(optional),
-    finish: Schema.String.pipe(optional),
-    cost: Schema.Finite.pipe(optional),
-    tokens: Schema.Struct({
-        input: Schema.Finite,
-        output: Schema.Finite,
-        reasoning: Schema.Finite,
-        cache: Schema.Struct({ read: Schema.Finite, write: Schema.Finite }),
-    }).pipe(optional),
-    error: UnknownError.pipe(optional),
-    time: Schema.Struct({
-        created: DateTimeUtcFromMillis,
-        completed: DateTimeUtcFromMillis.pipe(optional),
-    }),
-}).annotate({ identifier: "Session.Message.Assistant" });
-export const Compaction = Schema.Struct({
-    type: Schema.Literal("compaction"),
-    reason: Schema.Literals(["auto", "manual"]),
-    summary: Schema.String,
-    recent: Schema.String,
-    ...Base,
-}).annotate({ identifier: "Session.Message.Compaction" });
-export const Message = Schema.Union([
-    AgentSelected,
-    ModelSelected,
-    User,
-    Synthetic,
-    System,
-    Skill,
-    Shell,
-    Assistant,
-    Compaction,
-])
-    .pipe(Schema.toTaggedUnion("type"))
-    .annotate({ identifier: "Session.Message" });

package/dist/session-status-event.d.ts

@@ -1,299 +0,0 @@
-export * as SessionStatusEvent from "./session-status-event.js";
-import { Schema } from "effect";
-export declare const Info: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"idle">;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"retry">;
-    readonly attempt: Schema.Int;
-    readonly message: Schema.String;
-    readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly reason: Schema.String;
-        readonly provider: Schema.String;
-        readonly title: Schema.String;
-        readonly message: Schema.String;
-        readonly label: Schema.String;
-        readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly reason: Schema.String;
-        readonly provider: Schema.String;
-        readonly title: Schema.String;
-        readonly message: Schema.String;
-        readonly label: Schema.String;
-        readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>>, never, never>;
-    readonly next: Schema.Int;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"busy">;
-}>]>;
-export type Info = Schema.Schema.Type<typeof Info>;
-export declare const Status: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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 type: Schema.Literal<"session.status">;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly status: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"idle">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"retry">;
-            readonly attempt: Schema.Int;
-            readonly message: Schema.String;
-            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>, never, never>;
-            readonly next: Schema.Int;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"busy">;
-        }>]>;
-    }>;
-}> & {
-    type: "session.status";
-    durability: "ephemeral";
-    durable: undefined;
-    data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly status: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"idle">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"retry">;
-            readonly attempt: Schema.Int;
-            readonly message: Schema.String;
-            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>, never, never>;
-            readonly next: Schema.Int;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"busy">;
-        }>]>;
-    }>;
-};
-export declare const Idle: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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 type: Schema.Literal<"session.idle">;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-    }>;
-}> & {
-    type: "session.idle";
-    durability: "ephemeral";
-    durable: undefined;
-    data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-    }>;
-};
-export declare const Definitions: readonly [Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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 type: Schema.Literal<"session.status">;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly status: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"idle">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"retry">;
-            readonly attempt: Schema.Int;
-            readonly message: Schema.String;
-            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>, never, never>;
-            readonly next: Schema.Int;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"busy">;
-        }>]>;
-    }>;
-}> & {
-    type: "session.status";
-    durability: "ephemeral";
-    durable: undefined;
-    data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-        readonly status: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"idle">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"retry">;
-            readonly attempt: Schema.Int;
-            readonly message: Schema.String;
-            readonly action: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly reason: Schema.String;
-                readonly provider: Schema.String;
-                readonly title: Schema.String;
-                readonly message: Schema.String;
-                readonly label: Schema.String;
-                readonly link: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>, never, never>;
-            readonly next: Schema.Int;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"busy">;
-        }>]>;
-    }>;
-}, Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Event.ID">;
-    };
-    readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-    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 type: Schema.Literal<"session.idle">;
-    readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-        }>, never, never>;
-    }>>, never, never>;
-    readonly data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-    }>;
-}> & {
-    type: "session.idle";
-    durability: "ephemeral";
-    durable: undefined;
-    data: Schema.Struct<{
-        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-            create: () => string & import("effect/Brand").Brand<"SessionID">;
-            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-        };
-    }>;
-}];

package/dist/session-status-event.js

@@ -1,43 +0,0 @@
-export * as SessionStatusEvent from "./session-status-event.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { Event } from "./event.js";
-import { NonNegativeInt } from "./schema.js";
-import { SessionID } from "./session-id.js";
-export const Info = Schema.Union([
-    Schema.Struct({
-        type: Schema.Literal("idle"),
-    }),
-    Schema.Struct({
-        type: Schema.Literal("retry"),
-        attempt: NonNegativeInt,
-        message: Schema.String,
-        action: optional(Schema.Struct({
-            reason: Schema.String,
-            provider: Schema.String,
-            title: Schema.String,
-            message: Schema.String,
-            label: Schema.String,
-            link: optional(Schema.String),
-        })),
-        next: NonNegativeInt,
-    }),
-    Schema.Struct({
-        type: Schema.Literal("busy"),
-    }),
-]).annotate({ identifier: "SessionStatus" });
-export const Status = Event.ephemeral({
-    type: "session.status",
-    schema: {
-        sessionID: SessionID,
-        status: Info,
-    },
-});
-// deprecated
-export const Idle = Event.ephemeral({
-    type: "session.idle",
-    schema: {
-        sessionID: SessionID,
-    },
-});
-export const Definitions = Event.inventory(Status, Idle);

package/dist/session-todo.d.ts

@@ -1,117 +0,0 @@
-export * as SessionTodo from "./session-todo.js";
-import { Schema } from "effect";
-export declare const Info: Schema.Struct<{
-    readonly content: Schema.String;
-    readonly status: Schema.String;
-    readonly priority: Schema.String;
-}>;
-export interface Info extends Schema.Schema.Type<typeof Info> {
-}
-export declare const Event: {
-    Updated: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        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 type: Schema.Literal<"todo.updated">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly todos: Schema.$Array<Schema.Struct<{
-                readonly content: Schema.String;
-                readonly status: Schema.String;
-                readonly priority: Schema.String;
-            }>>;
-        }>;
-    }> & {
-        type: "todo.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly todos: Schema.$Array<Schema.Struct<{
-                readonly content: Schema.String;
-                readonly status: Schema.String;
-                readonly priority: Schema.String;
-            }>>;
-        }>;
-    };
-    Definitions: readonly [Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        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 type: Schema.Literal<"todo.updated">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly todos: Schema.$Array<Schema.Struct<{
-                readonly content: Schema.String;
-                readonly status: Schema.String;
-                readonly priority: Schema.String;
-            }>>;
-        }>;
-    }> & {
-        type: "todo.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
-                create: () => string & import("effect/Brand").Brand<"SessionID">;
-                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-            };
-            readonly todos: Schema.$Array<Schema.Struct<{
-                readonly content: Schema.String;
-                readonly status: Schema.String;
-                readonly priority: Schema.String;
-            }>>;
-        }>;
-    }];
-};

package/dist/session-todo.js

@@ -1,21 +0,0 @@
-export * as SessionTodo from "./session-todo.js";
-import { Schema } from "effect";
-import { ephemeral, inventory } from "./event.js";
-import { SessionID } from "./session-id.js";
-export const Info = Schema.Struct({
-    content: Schema.String.annotate({ description: "Brief description of the task" }),
-    status: Schema.String.annotate({
-        description: "Current status of the task: pending, in_progress, completed, cancelled",
-    }),
-    priority: Schema.String.annotate({
-        description: "Priority level of the task: high, medium, low",
-    }),
-}).annotate({ identifier: "Todo" });
-const Updated = ephemeral({
-    type: "todo.updated",
-    schema: {
-        sessionID: SessionID,
-        todos: Schema.Array(Info),
-    },
-});
-export const Event = { Updated, Definitions: inventory(Updated) };

package/dist/session-v1.d.ts

@@ -1 +0,0 @@
-export * from "./v1/session.js";