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

package/dist/session-event.js

@@ -1,423 +0,0 @@
-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 { 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";
-import { Shell as ShellSchema } from "./shell.js";
-export { FileAttachment };
-export const Source = Schema.Struct({
-    start: NonNegativeInt,
-    end: NonNegativeInt,
-    text: Schema.String,
-}).annotate({
-    identifier: "session.event.source",
-});
-const Base = {
-    sessionID: SessionID,
-};
-const PromptFields = {
-    ...Base,
-    inputID: SessionMessage.ID,
-    prompt: Prompt,
-    delivery: Delivery,
-};
-const options = {
-    durable: {
-        aggregate: "sessionID",
-        version: 1,
-    },
-};
-const stepSettlementOptions = {
-    durable: {
-        aggregate: "sessionID",
-        version: 1,
-    },
-};
-export const UnknownError = SessionMessage.UnknownError;
-export const AgentSelected = Event.durable({
-    type: "session.agent.selected",
-    ...options,
-    schema: {
-        ...Base,
-        agent: Schema.String,
-    },
-});
-export const ModelSelected = Event.durable({
-    type: "session.model.selected",
-    ...options,
-    schema: {
-        ...Base,
-        model: Model.Ref,
-    },
-});
-export const Moved = Event.durable({
-    type: "session.moved",
-    ...options,
-    schema: {
-        ...Base,
-        location: Location.Ref,
-        subpath: RelativePath.pipe(optional),
-    },
-});
-export const Renamed = Event.durable({
-    type: "session.renamed",
-    ...options,
-    schema: {
-        ...Base,
-        title: Schema.String,
-    },
-});
-export const Forked = Event.durable({
-    type: "session.forked",
-    ...options,
-    schema: {
-        ...Base,
-        parentID: SessionID,
-        from: SessionMessage.ID.pipe(optional),
-    },
-});
-export const PromptPromoted = Event.durable({
-    type: "session.prompt.promoted",
-    ...options,
-    schema: {
-        sessionID: SessionID,
-        inputID: SessionMessage.ID,
-    },
-});
-export const PromptAdmitted = Event.durable({
-    type: "session.prompt.admitted",
-    ...options,
-    schema: PromptFields,
-});
-export const ExecutionSettled = Event.ephemeral({
-    type: "session.execution.settled",
-    schema: {
-        ...Base,
-        outcome: Schema.Literals(["success", "failure", "interrupted"]),
-        error: UnknownError.pipe(optional),
-    },
-});
-export const ContextUpdated = Event.durable({
-    type: "session.context.updated",
-    ...options,
-    schema: {
-        ...Base,
-        text: Schema.String,
-    },
-});
-export const Synthetic = Event.durable({
-    type: "session.synthetic",
-    ...options,
-    schema: {
-        ...Base,
-        text: Schema.String,
-        description: Schema.String.pipe(optional),
-        metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
-    },
-});
-export var Skill;
-(function (Skill) {
-    Skill.Activated = Event.durable({
-        type: "session.skill.activated",
-        ...options,
-        schema: {
-            ...Base,
-            name: Schema.String,
-            text: Schema.String,
-        },
-    });
-})(Skill || (Skill = {}));
-export var Shell;
-(function (Shell) {
-    Shell.Started = Event.durable({
-        type: "session.shell.started",
-        ...options,
-        schema: {
-            ...Base,
-            shell: ShellSchema.Info,
-        },
-    });
-    Shell.Ended = Event.durable({
-        type: "session.shell.ended",
-        ...options,
-        schema: {
-            ...Base,
-            shell: ShellSchema.Info,
-            output: ShellSchema.Output,
-        },
-    });
-})(Shell || (Shell = {}));
-export var Step;
-(function (Step) {
-    Step.Started = Event.durable({
-        type: "session.step.started",
-        ...options,
-        schema: {
-            ...Base,
-            assistantMessageID: SessionMessage.ID,
-            agent: Schema.String,
-            model: Model.Ref,
-            snapshot: Schema.String.pipe(optional),
-        },
-    });
-    Step.Ended = Event.durable({
-        type: "session.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.durable({
-        type: "session.step.failed",
-        ...stepSettlementOptions,
-        schema: {
-            ...Base,
-            assistantMessageID: SessionMessage.ID,
-            error: UnknownError,
-        },
-    });
-})(Step || (Step = {}));
-export var Text;
-(function (Text) {
-    Text.Started = Event.durable({
-        type: "session.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.ephemeral({
-        type: "session.text.delta",
-        schema: {
-            ...Base,
-            assistantMessageID: SessionMessage.ID,
-            textID: Schema.String,
-            delta: Schema.String,
-        },
-    });
-    Text.Ended = Event.durable({
-        type: "session.text.ended",
-        ...options,
-        schema: {
-            ...Base,
-            assistantMessageID: SessionMessage.ID,
-            textID: Schema.String,
-            text: Schema.String,
-        },
-    });
-})(Text || (Text = {}));
-export var Reasoning;
-(function (Reasoning) {
-    Reasoning.Started = Event.durable({
-        type: "session.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.ephemeral({
-        type: "session.reasoning.delta",
-        schema: {
-            ...Base,
-            assistantMessageID: SessionMessage.ID,
-            reasoningID: Schema.String,
-            delta: Schema.String,
-        },
-    });
-    Reasoning.Ended = Event.durable({
-        type: "session.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.durable({
-            type: "session.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.ephemeral({
-            type: "session.tool.input.delta",
-            schema: {
-                ...ToolBase,
-                delta: Schema.String,
-            },
-        });
-        Input.Ended = Event.durable({
-            type: "session.tool.input.ended",
-            ...options,
-            schema: {
-                ...ToolBase,
-                text: Schema.String,
-            },
-        });
-    })(Input = Tool.Input || (Tool.Input = {}));
-    Tool.Called = Event.durable({
-        type: "session.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.durable({
-        type: "session.tool.progress",
-        ...options,
-        schema: {
-            ...ToolBase,
-            structured: Schema.Record(Schema.String, Schema.Unknown),
-            content: Schema.Array(ToolContent),
-        },
-    });
-    Tool.Success = Event.durable({
-        type: "session.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.durable({
-        type: "session.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.retry.error",
-});
-export const Retried = Event.durable({
-    type: "session.retried",
-    ...options,
-    schema: {
-        ...Base,
-        attempt: Schema.Finite,
-        error: RetryError,
-    },
-});
-export var Compaction;
-(function (Compaction) {
-    Compaction.Started = Event.durable({
-        type: "session.compaction.started",
-        ...options,
-        schema: {
-            ...Base,
-            reason: Schema.Union([Schema.Literal("auto"), Schema.Literal("manual")]),
-        },
-    });
-    Compaction.Delta = Event.ephemeral({
-        type: "session.compaction.delta",
-        schema: {
-            ...Base,
-            text: Schema.String,
-        },
-    });
-    Compaction.Ended = Event.durable({
-        type: "session.compaction.ended",
-        ...options,
-        schema: {
-            ...Base,
-            reason: Compaction.Started.data.fields.reason,
-            text: Schema.String,
-            recent: Schema.String,
-        },
-    });
-})(Compaction || (Compaction = {}));
-export var RevertEvent;
-(function (RevertEvent) {
-    RevertEvent.Staged = Event.durable({
-        type: "session.revert.staged",
-        ...options,
-        schema: { ...Base, revert: Revert.State },
-    });
-    RevertEvent.Cleared = Event.durable({ type: "session.revert.cleared", ...options, schema: Base });
-    RevertEvent.Committed = Event.durable({
-        type: "session.revert.committed",
-        ...options,
-        schema: { ...Base, messageID: SessionMessage.ID },
-    });
-})(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(AgentSelected, ModelSelected, Moved, Renamed, Forked, PromptPromoted, PromptAdmitted, ExecutionSettled, 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 DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"));
-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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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">;
-        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 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

@@ -1,18 +0,0 @@
-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" });