@opencode-ai/schema 0.0.0-next-14659

package/dist/session-event.js

@@ -0,0 +1,421 @@
+export * as SessionEvent from "./session-event.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Event } from "./event.js";
+import { ProviderMetadata, ToolContent } from "./llm.js";
+import { Delivery } from "./session-delivery.js";
+import { Model } from "./model.js";
+import { DateTimeUtcFromMillis, NonNegativeInt, RelativePath } from "./schema.js";
+import { FileAttachment, Prompt } from "./prompt.js";
+import { SessionID } from "./session-id.js";
+import { Location } from "./location.js";
+import { SessionMessage } from "./session-message.js";
+import { Revert } from "./revert.js";
+export { FileAttachment };
+export const Source = Schema.Struct({
+    start: NonNegativeInt,
+    end: NonNegativeInt,
+    text: Schema.String,
+}).annotate({
+    identifier: "session.next.event.source",
+});
+const Base = {
+    timestamp: DateTimeUtcFromMillis,
+    sessionID: SessionID,
+};
+const PromptFields = {
+    ...Base,
+    messageID: SessionMessage.ID,
+    prompt: Prompt,
+    delivery: Delivery,
+};
+const options = {
+    durable: {
+        aggregate: "sessionID",
+        version: 1,
+    },
+};
+const stepSettlementOptions = {
+    durable: {
+        aggregate: "sessionID",
+        version: 2,
+    },
+};
+export const UnknownError = SessionMessage.UnknownError;
+export const AgentSwitched = Event.define({
+    type: "session.next.agent.switched",
+    ...options,
+    schema: {
+        ...Base,
+        messageID: SessionMessage.ID,
+        agent: Schema.String,
+    },
+});
+export const ModelSwitched = Event.define({
+    type: "session.next.model.switched",
+    ...options,
+    schema: {
+        ...Base,
+        messageID: SessionMessage.ID,
+        model: Model.Ref,
+    },
+});
+export const Moved = Event.define({
+    type: "session.next.moved",
+    ...options,
+    schema: {
+        ...Base,
+        location: Location.Ref,
+        subdirectory: RelativePath.pipe(optional),
+    },
+});
+export const Renamed = Event.define({
+    type: "session.next.renamed",
+    ...options,
+    schema: {
+        ...Base,
+        title: Schema.String,
+    },
+});
+export const Forked = Event.define({
+    type: "session.next.forked",
+    ...options,
+    schema: {
+        ...Base,
+        parentID: SessionID,
+        messageID: SessionMessage.ID.pipe(optional),
+    },
+});
+export const Prompted = Event.define({
+    type: "session.next.prompted",
+    ...options,
+    schema: PromptFields,
+});
+export const PromptAdmitted = Event.define({
+    type: "session.next.prompt.admitted",
+    ...options,
+    schema: PromptFields,
+});
+export const ContextUpdated = Event.define({
+    type: "session.next.context.updated",
+    ...options,
+    schema: {
+        ...Base,
+        messageID: SessionMessage.ID,
+        text: Schema.String,
+    },
+});
+export const Synthetic = Event.define({
+    type: "session.next.synthetic",
+    ...options,
+    schema: {
+        ...Base,
+        messageID: SessionMessage.ID,
+        text: Schema.String,
+        description: Schema.String.pipe(optional),
+    },
+});
+export var Skill;
+(function (Skill) {
+    Skill.Activated = Event.define({
+        type: "session.next.skill.activated",
+        ...options,
+        schema: {
+            ...Base,
+            messageID: SessionMessage.ID,
+            name: Schema.String,
+            text: Schema.String,
+        },
+    });
+})(Skill || (Skill = {}));
+export var Shell;
+(function (Shell) {
+    Shell.Started = Event.define({
+        type: "session.next.shell.started",
+        ...options,
+        schema: {
+            ...Base,
+            messageID: SessionMessage.ID,
+            callID: Schema.String,
+            command: Schema.String,
+        },
+    });
+    Shell.Ended = Event.define({
+        type: "session.next.shell.ended",
+        ...options,
+        schema: {
+            ...Base,
+            callID: Schema.String,
+            output: Schema.String,
+        },
+    });
+})(Shell || (Shell = {}));
+export var Step;
+(function (Step) {
+    Step.Started = Event.define({
+        type: "session.next.step.started",
+        ...options,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            agent: Schema.String,
+            model: Model.Ref,
+            snapshot: Schema.String.pipe(optional),
+        },
+    });
+    Step.Ended = Event.define({
+        type: "session.next.step.ended",
+        ...stepSettlementOptions,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            finish: Schema.String,
+            cost: Schema.Finite,
+            tokens: Schema.Struct({
+                input: Schema.Finite,
+                output: Schema.Finite,
+                reasoning: Schema.Finite,
+                cache: Schema.Struct({
+                    read: Schema.Finite,
+                    write: Schema.Finite,
+                }),
+            }),
+            snapshot: Schema.String.pipe(optional),
+            files: Schema.Array(RelativePath).pipe(optional),
+        },
+    });
+    Step.Failed = Event.define({
+        type: "session.next.step.failed",
+        ...stepSettlementOptions,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            error: UnknownError,
+        },
+    });
+})(Step || (Step = {}));
+export var Text;
+(function (Text) {
+    Text.Started = Event.define({
+        type: "session.next.text.started",
+        ...options,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            textID: Schema.String,
+        },
+    });
+    // Stream fragments are live-only; Text.Ended is the replayable full-value boundary.
+    Text.Delta = Event.define({
+        type: "session.next.text.delta",
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            textID: Schema.String,
+            delta: Schema.String,
+        },
+    });
+    Text.Ended = Event.define({
+        type: "session.next.text.ended",
+        ...options,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            textID: Schema.String,
+            text: Schema.String,
+        },
+    });
+})(Text || (Text = {}));
+export var Reasoning;
+(function (Reasoning) {
+    Reasoning.Started = Event.define({
+        type: "session.next.reasoning.started",
+        ...options,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            reasoningID: Schema.String,
+            providerMetadata: ProviderMetadata.pipe(optional),
+        },
+    });
+    // Stream fragments are live-only; Reasoning.Ended is the replayable full-value boundary.
+    Reasoning.Delta = Event.define({
+        type: "session.next.reasoning.delta",
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            reasoningID: Schema.String,
+            delta: Schema.String,
+        },
+    });
+    Reasoning.Ended = Event.define({
+        type: "session.next.reasoning.ended",
+        ...options,
+        schema: {
+            ...Base,
+            assistantMessageID: SessionMessage.ID,
+            reasoningID: Schema.String,
+            text: Schema.String,
+            providerMetadata: ProviderMetadata.pipe(optional),
+        },
+    });
+})(Reasoning || (Reasoning = {}));
+export var Tool;
+(function (Tool) {
+    const ToolBase = {
+        ...Base,
+        assistantMessageID: SessionMessage.ID,
+        callID: Schema.String,
+    };
+    let Input;
+    (function (Input) {
+        Input.Started = Event.define({
+            type: "session.next.tool.input.started",
+            ...options,
+            schema: {
+                ...ToolBase,
+                name: Schema.String,
+            },
+        });
+        // Stream fragments are live-only; Input.Ended is the replayable raw-input boundary.
+        Input.Delta = Event.define({
+            type: "session.next.tool.input.delta",
+            schema: {
+                ...ToolBase,
+                delta: Schema.String,
+            },
+        });
+        Input.Ended = Event.define({
+            type: "session.next.tool.input.ended",
+            ...options,
+            schema: {
+                ...ToolBase,
+                text: Schema.String,
+            },
+        });
+    })(Input = Tool.Input || (Tool.Input = {}));
+    Tool.Called = Event.define({
+        type: "session.next.tool.called",
+        ...options,
+        schema: {
+            ...ToolBase,
+            tool: Schema.String,
+            input: Schema.Record(Schema.String, Schema.Unknown),
+            provider: Schema.Struct({
+                executed: Schema.Boolean,
+                metadata: ProviderMetadata.pipe(optional),
+            }),
+        },
+    });
+    /**
+     * Replayable bounded running-tool state. Tools should checkpoint semantic
+     * transitions or at a bounded cadence, not persist every stdout/stderr chunk.
+     */
+    Tool.Progress = Event.define({
+        type: "session.next.tool.progress",
+        ...options,
+        schema: {
+            ...ToolBase,
+            structured: Schema.Record(Schema.String, Schema.Unknown),
+            content: Schema.Array(ToolContent),
+        },
+    });
+    Tool.Success = Event.define({
+        type: "session.next.tool.success",
+        ...options,
+        schema: {
+            ...ToolBase,
+            structured: Schema.Record(Schema.String, Schema.Unknown),
+            content: Schema.Array(ToolContent),
+            outputPaths: Schema.Array(Schema.String).pipe(optional),
+            result: Schema.Unknown.pipe(optional),
+            provider: Schema.Struct({
+                executed: Schema.Boolean,
+                metadata: ProviderMetadata.pipe(optional),
+            }),
+        },
+    });
+    Tool.Failed = Event.define({
+        type: "session.next.tool.failed",
+        ...options,
+        schema: {
+            ...ToolBase,
+            error: UnknownError,
+            result: Schema.Unknown.pipe(optional),
+            provider: Schema.Struct({
+                executed: Schema.Boolean,
+                metadata: ProviderMetadata.pipe(optional),
+            }),
+        },
+    });
+})(Tool || (Tool = {}));
+export const RetryError = Schema.Struct({
+    message: Schema.String,
+    statusCode: Schema.Finite.pipe(optional),
+    isRetryable: Schema.Boolean,
+    responseHeaders: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    responseBody: Schema.String.pipe(optional),
+    metadata: Schema.Record(Schema.String, Schema.String).pipe(optional),
+}).annotate({
+    identifier: "session.next.retry_error",
+});
+export const Retried = Event.define({
+    type: "session.next.retried",
+    ...options,
+    schema: {
+        ...Base,
+        attempt: Schema.Finite,
+        error: RetryError,
+    },
+});
+export var Compaction;
+(function (Compaction) {
+    Compaction.Started = Event.define({
+        type: "session.next.compaction.started",
+        ...options,
+        schema: {
+            ...Base,
+            messageID: SessionMessage.ID,
+            reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
+        },
+    });
+    Compaction.Delta = Event.define({
+        type: "session.next.compaction.delta",
+        schema: {
+            ...Base,
+            messageID: SessionMessage.ID,
+            text: Schema.String,
+        },
+    });
+    Compaction.Ended = Event.define({
+        type: "session.next.compaction.ended",
+        ...options,
+        schema: {
+            ...Base,
+            messageID: SessionMessage.ID,
+            reason: Compaction.Started.data.fields.reason,
+            text: Schema.String,
+            recent: Schema.String,
+        },
+    });
+})(Compaction || (Compaction = {}));
+export var RevertEvent;
+(function (RevertEvent) {
+    RevertEvent.Staged = Event.define({
+        type: "session.next.revert.staged",
+        ...options,
+        schema: { ...Base, revert: Revert.State },
+    });
+    RevertEvent.Cleared = Event.define({ type: "session.next.revert.cleared", ...options, schema: Base });
+    RevertEvent.Committed = Event.define({
+        type: "session.next.revert.committed",
+        ...options,
+        schema: { ...Base, messageID: SessionMessage.ID },
+    });
+})(RevertEvent || (RevertEvent = {}));
+export const DurableDefinitions = Event.inventory(AgentSwitched, ModelSwitched, Moved, Renamed, Forked, Prompted, PromptAdmitted, ContextUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Ended, Step.Failed, Text.Started, Text.Ended, Tool.Input.Started, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, Reasoning.Started, Reasoning.Ended, Retried, Compaction.Started, Compaction.Ended, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Definitions = Event.inventory(AgentSwitched, ModelSwitched, Moved, Renamed, Forked, Prompted, PromptAdmitted, ContextUpdated, 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, Retried, Compaction.Started, Compaction.Delta, Compaction.Ended, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Durable = Schema.Union(DurableDefinitions, { mode: "oneOf" })
+    .pipe(Schema.toTaggedUnion("type"))
+    .annotate({ identifier: "SessionDurableEvent" });
+export const All = Schema.Union(Definitions, { mode: "oneOf" }).pipe(Schema.toTaggedUnion("type"));

package/dist/session-id.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "effect";
+export declare const SessionID: Schema.brand<Schema.String, "SessionID"> & {
+    create: () => string & import("effect/Brand").Brand<"SessionID">;
+    descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+};
+export type SessionID = typeof SessionID.Type;

package/dist/session-id.js

@@ -0,0 +1,10 @@
+import { Schema } from "effect";
+import { descending } from "./identifier.js";
+import { statics } from "./schema.js";
+export const SessionID = Schema.String.check(Schema.isStartsWith("ses")).pipe(Schema.brand("SessionID"), statics((schema) => {
+    const create = () => schema.make("ses_" + descending());
+    return {
+        create,
+        descending: (id) => (id === undefined ? create() : schema.make(id)),
+    };
+}));

package/dist/session-input.d.ts

@@ -0,0 +1,145 @@
+export * as SessionInput from "./session-input.js";
+import { Schema } from "effect";
+import { Prompt } from "./prompt.js";
+import { SessionDelivery } from "./session-delivery.js";
+export declare const Delivery: Schema.Literals<readonly ["steer", "queue"]>;
+export type Delivery = SessionDelivery.Delivery;
+export interface Admitted extends Schema.Schema.Type<typeof Admitted> {
+}
+export declare const Admitted: Schema.Struct<{
+    readonly admittedSeq: Schema.Int;
+    readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
+        create: () => 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 prompt: Schema.Struct<{
+        readonly text: Schema.String;
+        readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly uri: Schema.String;
+            readonly mime: 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 source: 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 uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            };
+        }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly uri: Schema.String;
+            readonly mime: 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 source: 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 uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    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 source: 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 source: 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>;
+    }> & {
+        equivalence: import("effect/Equivalence").Equivalence<{
+            readonly text: string;
+            readonly files?: readonly {
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly agents?: readonly {
+                readonly name: string;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+        }>;
+        fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
+            readonly text: string;
+            readonly files?: readonly {
+                readonly uri: string;
+                readonly mime: string;
+                readonly name?: string | undefined;
+                readonly description?: string | undefined;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+            readonly agents?: readonly {
+                readonly name: string;
+                readonly source?: {
+                    readonly start: number;
+                    readonly end: number;
+                    readonly text: string;
+                } | undefined;
+            }[] | undefined;
+        };
+    };
+    readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
+    readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+    readonly promotedSeq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;

package/dist/session-input.js

@@ -0,0 +1,18 @@
+export * as SessionInput from "./session-input.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { Prompt } from "./prompt.js";
+import { DateTimeUtcFromMillis, NonNegativeInt } 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 Admitted = Schema.Struct({
+    admittedSeq: NonNegativeInt,
+    id: SessionMessage.ID,
+    sessionID: SessionID,
+    prompt: Prompt,
+    delivery: Delivery,
+    timeCreated: DateTimeUtcFromMillis,
+    promotedSeq: NonNegativeInt.pipe(optional),
+}).annotate({ identifier: "SessionInput.Admitted" });