@opencode-ai/schema 0.0.0-next-14659

package/dist/session-message.js

@@ -0,0 +1,171 @@
+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";
+export const ID = Schema.String.check(Schema.isStartsWith("msg_")).pipe(Schema.brand("Session.Message.ID"), statics((schema) => ({ create: () => schema.make("msg_" + ascending()) })));
+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 AgentSwitched = Schema.Struct({
+    ...Base,
+    type: Schema.Literal("agent-switched"),
+    agent: Schema.String,
+}).annotate({ identifier: "Session.Message.AgentSwitched" });
+export const ModelSwitched = Schema.Struct({
+    ...Base,
+    type: Schema.Literal("model-switched"),
+    model: Model.Ref,
+}).annotate({ identifier: "Session.Message.ModelSwitched" });
+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"),
+    callID: Schema.String,
+    command: Schema.String,
+    output: Schema.String,
+    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([
+    AgentSwitched,
+    ModelSwitched,
+    User,
+    Synthetic,
+    System,
+    Skill,
+    Shell,
+    Assistant,
+    Compaction,
+])
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "Session.Message" });

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

@@ -0,0 +1,339 @@
+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 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 durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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">;
+        }>]>;
+    }>;
+}> & {
+    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">;
+        }>]>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.status";
+};
+export declare const Idle: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.idle">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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">;
+        };
+    }>;
+}> & {
+    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">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.idle";
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.status">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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">;
+        }>]>;
+    }>;
+}> & {
+    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">;
+        }>]>;
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.status";
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.idle">;
+    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.Int;
+        readonly version: Schema.Int;
+    }>>, never, never>;
+    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">;
+        };
+    }>;
+}> & {
+    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">;
+        };
+    }>;
+    durable?: {
+        readonly version: number;
+        readonly aggregate: string;
+    } | undefined;
+    type: "session.idle";
+}];

package/dist/session-status-event.js

@@ -0,0 +1,43 @@
+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.define({
+    type: "session.status",
+    schema: {
+        sessionID: SessionID,
+        status: Info,
+    },
+});
+// deprecated
+export const Idle = Event.define({
+    type: "session.idle",
+    schema: {
+        sessionID: SessionID,
+    },
+});
+export const Definitions = Event.inventory(Status, Idle);