@opencode-ai/schema - npm Package Compare versions

Comparing version 0.0.0-next-17343 to 0.0.0-next-17346

dist/session-inbox.d.ts

+export * as SessionInbox from "./session-inbox.js";
+import { Schema } from "effect";
+export declare const Delivery: Schema.Literals<readonly ["steer", "queue"]>;
+export type Delivery = typeof Delivery.Type;
+export interface UserPayload extends Schema.Schema.Type<typeof UserPayload> {
+}
+export declare const UserPayload: Schema.Struct<{
+    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 text: Schema.String;
+    readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly data: Schema.String;
+        readonly mime: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"inline">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"uri">;
+            readonly uri: Schema.String;
+        }>]>;
+        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }> & {
+        create: (input: import("./prompt.js").FileAttachment) => {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        };
+    }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly data: Schema.String;
+        readonly mime: Schema.String;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"inline">;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"uri">;
+            readonly uri: Schema.String;
+        }>]>;
+        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }> & {
+        create: (input: import("./prompt.js").FileAttachment) => {
+            readonly data: string;
+            readonly source: {
+                readonly type: "inline";
+            } | {
+                readonly type: "uri";
+                readonly uri: string;
+            };
+            readonly mime: string;
+            readonly description?: string | undefined;
+            readonly name?: string | undefined;
+            readonly mention?: {
+                readonly start: number;
+                readonly end: number;
+                readonly text: string;
+            } | undefined;
+        };
+    }>>, never, never>;
+    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>, never, never>;
+    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly text: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
+        readonly text: Schema.String;
+        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly start: Schema.Finite;
+            readonly end: Schema.Finite;
+            readonly text: Schema.String;
+        }>>, never, never>;
+    }>>>, never, never>;
+}>;
+export interface SyntheticPayload extends Schema.Schema.Type<typeof SyntheticPayload> {
+}
+export declare const SyntheticPayload: Schema.Struct<{
+    readonly text: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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>;
+}>;
+export interface CompactionPayload extends Schema.Schema.Type<typeof CompactionPayload> {
+}
+export declare const CompactionPayload: Schema.Struct<{}>;
+export interface MovePayload extends Schema.Schema.Type<typeof MovePayload> {
+}
+export declare const MovePayload: Schema.Struct<{
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>;
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
+}>;
+export declare const Item: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"user">;
+    readonly payload: Schema.Struct<{
+        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 text: Schema.String;
+        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>, never, never>;
+        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"synthetic">;
+    readonly payload: Schema.Struct<{
+        readonly text: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"compaction">;
+    readonly payload: Schema.Struct<{}>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"move">;
+    readonly payload: Schema.Struct<{
+        readonly location: Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>;
+        readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+}>]>;
+export type Item = typeof Item.Type;
+export interface User extends Schema.Schema.Type<typeof User> {
+}
+export declare const User: Schema.Struct<{
+    readonly type: Schema.tag<"user">;
+    readonly payload: Schema.Struct<{
+        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 text: Schema.String;
+        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>, never, never>;
+        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>;
+export interface Synthetic extends Schema.Schema.Type<typeof Synthetic> {
+}
+export declare const Synthetic: Schema.Struct<{
+    readonly type: Schema.tag<"synthetic">;
+    readonly payload: Schema.Struct<{
+        readonly text: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>;
+export interface Compaction extends Schema.Schema.Type<typeof Compaction> {
+}
+export declare const Compaction: Schema.Struct<{
+    readonly type: Schema.tag<"compaction">;
+    readonly payload: Schema.Struct<{}>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>;
+export interface Move extends Schema.Schema.Type<typeof Move> {
+}
+export declare const Move: Schema.Struct<{
+    readonly type: Schema.tag<"move">;
+    readonly payload: Schema.Struct<{
+        readonly location: Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>;
+        readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>;
+export declare const Info: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.tag<"user">;
+    readonly payload: Schema.Struct<{
+        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 text: Schema.String;
+        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly data: Schema.String;
+            readonly mime: Schema.String;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"inline">;
+            }>, Schema.Struct<{
+                readonly type: Schema.Literal<"uri">;
+                readonly uri: Schema.String;
+            }>]>;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }> & {
+            create: (input: import("./prompt.js").FileAttachment) => {
+                readonly data: string;
+                readonly source: {
+                    readonly type: "inline";
+                } | {
+                    readonly type: "uri";
+                    readonly uri: string;
+                };
+                readonly mime: string;
+                readonly description?: string | undefined;
+                readonly name?: string | undefined;
+                readonly mention?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>, never, never>;
+        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Skill.ID">;
+            readonly name: Schema.brand<Schema.String, "Skill.Name">;
+            readonly text: Schema.String;
+            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly start: Schema.Finite;
+                readonly end: Schema.Finite;
+                readonly text: Schema.String;
+            }>>, never, never>;
+        }>>>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"synthetic">;
+    readonly payload: Schema.Struct<{
+        readonly text: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"compaction">;
+    readonly payload: Schema.Struct<{}>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.tag<"move">;
+    readonly payload: Schema.Struct<{
+        readonly location: Schema.Struct<{
+            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>;
+        readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+            global: string & import("effect/Brand").Brand<"Project.ID">;
+        };
+        readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
+    }>;
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+}>]>;
+export type Info = typeof Info.Type;

dist/session-inbox.js

+export * as SessionInbox from "./session-inbox.js";
+import { Schema } from "effect";
+import { Location } from "./location.js";
+import { Project } from "./project.js";
+import { Prompt } from "./prompt.js";
+import { DateTimeUtcFromMillis, optional, RelativePath } from "./schema.js";
+import { SessionID } from "./session-id.js";
+import { SessionMessage } from "./session-message.js";
+export const Delivery = Schema.Literals(["steer", "queue"]).annotate({ identifier: "Session.Inbox.Delivery" });
+export const UserPayload = Schema.Struct({
+    ...Prompt.fields,
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+}).annotate({ identifier: "Session.Inbox.UserPayload" });
+export const SyntheticPayload = Schema.Struct({
+    text: Schema.String,
+    description: Schema.String.pipe(optional),
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+}).annotate({ identifier: "Session.Inbox.SyntheticPayload" });
+export const CompactionPayload = Schema.Struct({}).annotate({ identifier: "Session.Inbox.CompactionPayload" });
+export const MovePayload = Schema.Struct({
+    location: Location.Ref,
+    projectID: Project.ID,
+    subpath: RelativePath.pipe(optional),
+}).annotate({ identifier: "Session.Inbox.MovePayload" });
+const UserItem = Schema.Struct({ type: Schema.tag("user"), payload: UserPayload, delivery: Delivery });
+const SyntheticItem = Schema.Struct({ type: Schema.tag("synthetic"), payload: SyntheticPayload, delivery: Delivery });
+const CompactionItem = Schema.Struct({
+    type: Schema.tag("compaction"),
+    payload: CompactionPayload,
+    delivery: Delivery,
+});
+const MoveItem = Schema.Struct({ type: Schema.tag("move"), payload: MovePayload, delivery: Delivery });
+export const Item = Schema.Union([UserItem, SyntheticItem, CompactionItem, MoveItem]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Session.Inbox.Item" }));
+const Enqueued = {
+    id: SessionMessage.ID,
+    sessionID: SessionID,
+    timeCreated: DateTimeUtcFromMillis,
+};
+export const User = Schema.Struct({ ...Enqueued, ...UserItem.fields }).annotate({ identifier: "Session.Inbox.User" });
+export const Synthetic = Schema.Struct({ ...Enqueued, ...SyntheticItem.fields }).annotate({
+    identifier: "Session.Inbox.Synthetic",
+});
+export const Compaction = Schema.Struct({ ...Enqueued, ...CompactionItem.fields }).annotate({
+    identifier: "Session.Inbox.Compaction",
+});
+export const Move = Schema.Struct({ ...Enqueued, ...MoveItem.fields }).annotate({ identifier: "Session.Inbox.Move" });
+export const Info = Schema.Union([User, Synthetic, Compaction, Move]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Session.Inbox.Info" }));

dist/index.d.ts

@@ -25,3 +25,3 @@ export { Agent } from "./agent.js";
 export { Vcs } from "./vcs.js";
-export { SessionPending } from "./session-pending.js";
+export { SessionInbox } from "./session-inbox.js";
 export { SessionError } from "./session-error.js";
@@ -28,0 +28,0 @@ export { SessionMessage } from "./session-message.js";

dist/index.js

@@ -25,3 +25,3 @@ export { Agent } from "./agent.js";
 export { Vcs } from "./vcs.js";
-export { SessionPending } from "./session-pending.js";
+export { SessionInbox } from "./session-inbox.js";
 export { SessionError } from "./session-error.js";
@@ -28,0 +28,0 @@ export { SessionMessage } from "./session-message.js";

dist/session-event.js

@@ -22,3 +22,3 @@ export * as SessionEvent from "./session-event.js";
 import { TokenUsage } from "./token-usage.js";
-import { SessionPending } from "./session-pending.js";
+import { SessionInbox } from "./session-inbox.js";
 import { Project } from "./project.js";
@@ -82,5 +82,3 @@ import { SessionFork } from "./session-fork.js";
         ...Base,
-        location: Location.Ref,
-        projectID: Project.ID.pipe(optional),
-        subpath: RelativePath.pipe(optional),
+        ...SessionInbox.MovePayload.fields,
     },
@@ -135,34 +133,29 @@ });
 });
-const InputRef = {
+const InboxRef = {
     ...Base,
-    inputID: SessionMessage.ID,
+    inboxID: SessionMessage.ID,
 };
-export const InputPromoted = Event.durable({
-    type: "session.input.promoted",
+export const InboxDelivered = Event.durable({
+    type: "session.inbox.delivered",
     ...options,
-    schema: InputRef,
+    schema: InboxRef,
 });
-export const InputAdmitted = Event.durable({
-    type: "session.input.admitted",
+export const InboxEnqueued = Event.durable({
+    type: "session.inbox.enqueued",
     ...options,
     schema: {
-        ...InputRef,
-        input: SessionPending.Message,
+        ...InboxRef,
+        item: SessionInbox.Item,
     },
 });
-export const InputCancelled = Event.durable({
-    type: "session.input.cancelled",
+export const InboxCancelled = Event.durable({
+    type: "session.inbox.cancelled",
     ...options,
-    schema: InputRef,
+    schema: InboxRef,
 });
-export const InputSteered = Event.durable({
-    type: "session.input.steered",
+export const InboxDeliveryChanged = Event.durable({
+    type: "session.inbox.delivery.changed",
     ...options,
-    schema: InputRef,
+    schema: { ...InboxRef, delivery: SessionInbox.Delivery },
 });
-export const InputQueued = Event.durable({
-    type: "session.input.queued",
-    ...options,
-    schema: InputRef,
-});
 export var Execution;
@@ -450,10 +443,2 @@ (function (Execution) {
 (function (Compaction) {
-    Compaction.Admitted = Event.durable({
-        type: "session.compaction.admitted",
-        ...options,
-        schema: {
-            ...Base,
-            inputID: SessionMessage.ID,
-        },
-    });
     Compaction.Started = Event.durable({
@@ -511,3 +496,3 @@ type: "session.compaction.started",
 })(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, UsageUpdated, Deleted, Forked, InputPromoted, InputAdmitted, InputCancelled, InputSteered, InputQueued, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Admitted, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
 // UsageRecorded is durable but internal: excluded from Definitions so it never reaches the public manifest.
@@ -514,0 +499,0 @@ export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded);

package.json

 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/schema",
-  "version": "0.0.0-next-17343",
+  "version": "0.0.0-next-17346",
   "type": "module",
@@ -6,0 +6,0 @@ "license": "MIT",

dist/session-delivery.d.ts

-export * as SessionDelivery from "./session-delivery.js";
-import { Schema } from "effect";
-export declare const Delivery: Schema.Literals<readonly ["steer", "queue"]>;
-export type Delivery = typeof Delivery.Type;

dist/session-delivery.js

-export * as SessionDelivery from "./session-delivery.js";
-import { Schema } from "effect";
-export const Delivery = Schema.Literals(["steer", "queue"]);

dist/session-pending.d.ts

-export * as SessionPending from "./session-pending.js";
-import { Schema } from "effect";
-import { SessionDelivery } from "./session-delivery.js";
-export declare const Delivery: Schema.Literals<readonly ["steer", "queue"]>;
-export type Delivery = SessionDelivery.Delivery;
-export interface UserData extends Schema.Schema.Type<typeof UserData> {
-}
-export declare const UserData: Schema.Struct<{
-    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 text: Schema.String;
-    readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-        readonly data: Schema.String;
-        readonly mime: Schema.String;
-        readonly source: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"inline">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"uri">;
-            readonly uri: Schema.String;
-        }>]>;
-        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }> & {
-        create: (input: import("./prompt.js").FileAttachment) => {
-            readonly data: string;
-            readonly source: {
-                readonly type: "inline";
-            } | {
-                readonly type: "uri";
-                readonly uri: string;
-            };
-            readonly mime: string;
-            readonly description?: string | undefined;
-            readonly name?: string | undefined;
-            readonly mention?: {
-                readonly start: number;
-                readonly end: number;
-                readonly text: string;
-            } | undefined;
-        };
-    }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-        readonly data: Schema.String;
-        readonly mime: Schema.String;
-        readonly source: Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"inline">;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"uri">;
-            readonly uri: Schema.String;
-        }>]>;
-        readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }> & {
-        create: (input: import("./prompt.js").FileAttachment) => {
-            readonly data: string;
-            readonly source: {
-                readonly type: "inline";
-            } | {
-                readonly type: "uri";
-                readonly uri: string;
-            };
-            readonly mime: string;
-            readonly description?: string | undefined;
-            readonly name?: string | undefined;
-            readonly mention?: {
-                readonly start: number;
-                readonly end: number;
-                readonly text: string;
-            } | undefined;
-        };
-    }>>, never, never>;
-    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }>>>, never, never>;
-    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Skill.ID">;
-        readonly name: Schema.brand<Schema.String, "Skill.Name">;
-        readonly text: Schema.String;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Skill.ID">;
-        readonly name: Schema.brand<Schema.String, "Skill.Name">;
-        readonly text: Schema.String;
-        readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly start: Schema.Finite;
-            readonly end: Schema.Finite;
-            readonly text: Schema.String;
-        }>>, never, never>;
-    }>>>, never, never>;
-}>;
-export interface SyntheticData extends Schema.Schema.Type<typeof SyntheticData> {
-}
-export declare const SyntheticData: Schema.Struct<{
-    readonly text: Schema.String;
-    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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>;
-}>;
-export interface UserMessage extends Schema.Schema.Type<typeof UserMessage> {
-}
-export declare const UserMessage: Schema.Struct<{
-    readonly type: Schema.tag<"user">;
-    readonly data: Schema.Struct<{
-        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 text: Schema.String;
-        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>, never, never>;
-        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-    }>;
-    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
-}>;
-export interface SyntheticMessage extends Schema.Schema.Type<typeof SyntheticMessage> {
-}
-export declare const SyntheticMessage: Schema.Struct<{
-    readonly type: Schema.tag<"synthetic">;
-    readonly data: Schema.Struct<{
-        readonly text: Schema.String;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
-}>;
-export declare const Message: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.tag<"user">;
-    readonly data: Schema.Struct<{
-        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 text: Schema.String;
-        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>, never, never>;
-        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-    }>;
-    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"synthetic">;
-    readonly data: Schema.Struct<{
-        readonly text: Schema.String;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
-}>]>;
-export type Message = typeof Message.Type;
-export interface User extends Schema.Schema.Type<typeof User> {
-}
-export declare const User: Schema.Struct<{
-    readonly type: Schema.tag<"user">;
-    readonly data: Schema.Struct<{
-        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 text: Schema.String;
-        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>, never, never>;
-        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-    }>;
-    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>;
-export interface Synthetic extends Schema.Schema.Type<typeof Synthetic> {
-}
-export declare const Synthetic: Schema.Struct<{
-    readonly type: Schema.tag<"synthetic">;
-    readonly data: Schema.Struct<{
-        readonly text: Schema.String;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>;
-export interface Compaction extends Schema.Schema.Type<typeof Compaction> {
-}
-export declare const Compaction: Schema.Struct<{
-    readonly type: Schema.tag<"compaction">;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>;
-export declare const Info: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.tag<"user">;
-    readonly data: Schema.Struct<{
-        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 text: Schema.String;
-        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly data: Schema.String;
-            readonly mime: Schema.String;
-            readonly source: Schema.Union<readonly [Schema.Struct<{
-                readonly type: Schema.Literal<"inline">;
-            }>, Schema.Struct<{
-                readonly type: Schema.Literal<"uri">;
-                readonly uri: Schema.String;
-            }>]>;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }> & {
-            create: (input: import("./prompt.js").FileAttachment) => {
-                readonly data: string;
-                readonly source: {
-                    readonly type: "inline";
-                } | {
-                    readonly type: "uri";
-                    readonly uri: string;
-                };
-                readonly mime: string;
-                readonly description?: string | undefined;
-                readonly name?: string | undefined;
-                readonly mention?: {
-                    readonly start: number;
-                    readonly end: number;
-                    readonly text: string;
-                } | undefined;
-            };
-        }>>, never, never>;
-        readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly name: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-        readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Skill.ID">;
-            readonly name: Schema.brand<Schema.String, "Skill.Name">;
-            readonly text: Schema.String;
-            readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly start: Schema.Finite;
-                readonly end: Schema.Finite;
-                readonly text: Schema.String;
-            }>>, never, never>;
-        }>>>, never, never>;
-    }>;
-    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"synthetic">;
-    readonly data: Schema.Struct<{
-        readonly text: Schema.String;
-        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, 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 delivery: Schema.Literals<readonly ["steer", "queue"]>;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.tag<"compaction">;
-    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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
-        create: () => string & import("effect/Brand").Brand<"SessionID">;
-        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
-    };
-    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-}>]>;
-export type Info = typeof Info.Type;

dist/session-pending.js

-export * as SessionPending from "./session-pending.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { Prompt } from "./prompt.js";
-import { DateTimeUtcFromMillis } from "./schema.js";
-import { SessionDelivery } from "./session-delivery.js";
-import { SessionID } from "./session-id.js";
-import { SessionMessage } from "./session-message.js";
-export const Delivery = SessionDelivery.Delivery;
-export const UserData = Schema.Struct({
-    ...Prompt.fields,
-    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
-}).annotate({ identifier: "SessionPending.UserData" });
-export const SyntheticData = Schema.Struct({
-    text: Schema.String,
-    description: Schema.String.pipe(optional),
-    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
-}).annotate({ identifier: "SessionPending.SyntheticData" });
-export const UserMessage = Schema.Struct({
-    type: Schema.tag("user"),
-    data: UserData,
-    delivery: Delivery,
-}).annotate({ identifier: "SessionPending.UserMessage" });
-export const SyntheticMessage = Schema.Struct({
-    type: Schema.tag("synthetic"),
-    data: SyntheticData,
-    delivery: Delivery,
-}).annotate({ identifier: "SessionPending.SyntheticMessage" });
-export const Message = Schema.Union([UserMessage, SyntheticMessage]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "SessionPending.Message" }));
-const Admitted = {
-    id: SessionMessage.ID,
-    sessionID: SessionID,
-    timeCreated: DateTimeUtcFromMillis,
-};
-export const User = Schema.Struct({
-    ...Admitted,
-    ...UserMessage.fields,
-}).annotate({ identifier: "SessionPending.User" });
-export const Synthetic = Schema.Struct({
-    ...Admitted,
-    ...SyntheticMessage.fields,
-}).annotate({ identifier: "SessionPending.Synthetic" });
-export const Compaction = Schema.Struct({
-    ...Admitted,
-    type: Schema.tag("compaction"),
-}).annotate({ identifier: "SessionPending.Compaction" });
-export const Info = Schema.Union([User, Synthetic, Compaction]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "SessionPending.Info" }));

New alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Fixed alerts

URL strings

Supply chain risk

Package contains fragments of external URLs or IP addresses, which the package may be accessing at runtime.

Worsened metrics

Total package byte prevSize

3815833

-0.93%

Number of package files

195

-1.02%

Lines of code

58993

-1.08%

No dependency changes