@opencode/schema 0.0.0-reserved → 2.0.1

package/dist/session-message.js

@@ -0,0 +1,227 @@
+export * as SessionMessage from "./session-message.js";
+import { Schema } from "effect";
+import { SessionProviderContext } from "./session-provider-context.js";
+import { optional } from "./schema.js";
+import { Content } from "./tool.js";
+import { Location } from "./location.js";
+import { Model } from "./model.js";
+import { Project } from "./project.js";
+import { Prompt } from "./prompt.js";
+import { DateTimeUtcFromMillis, PositiveInt, RelativePath, statics } from "./schema.js";
+import { ascending } from "./identifier.js";
+import { Event } from "./event.js";
+import { Shell as ShellSchema } from "./shell.js";
+import { FinishReason } from "./llm.js";
+import { SessionError } from "./session-error.js";
+import { Agent } from "./agent.js";
+import { Skill as SkillSchema } from "./skill.js";
+import { Money } from "./money.js";
+import { Snapshot } from "./snapshot.js";
+import { TokenUsage } from "./token-usage.js";
+export const ID = Schema.String.check(Schema.isStartsWith("msg_")).pipe(Schema.brand("Session.Message.ID"), statics((schema) => ({
+    create: () => schema.make("msg_" + ascending()),
+    fromEvent: (eventID) => schema.make(eventID.replace(/^evt_/, "msg_")),
+})));
+const Base = {
+    id: ID,
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+    time: Schema.Struct({ created: DateTimeUtcFromMillis }),
+};
+export const ProviderState = Schema.Record(Schema.String, Schema.Unknown).annotate({
+    identifier: "Session.Message.ProviderState",
+});
+export const AgentSelected = Schema.Struct({
+    ...Base,
+    type: Schema.tag("agent-switched"),
+    agent: Agent.ID,
+    previous: Agent.ID.pipe(optional),
+}).annotate({ identifier: "Session.Message.AgentSelected" });
+export const ModelSelected = Schema.Struct({
+    ...Base,
+    type: Schema.tag("model-switched"),
+    model: Model.Ref,
+    previous: Model.Ref.pipe(optional),
+}).annotate({ identifier: "Session.Message.ModelSelected" });
+export const LocationSwitched = Schema.Struct({
+    ...Base,
+    type: Schema.tag("location-switched"),
+    location: Location.Ref,
+    projectID: Project.ID.pipe(optional),
+    subpath: RelativePath.pipe(optional),
+    previous: Schema.Struct({
+        location: Location.Ref,
+        projectID: Project.ID.pipe(optional),
+        subpath: RelativePath.pipe(optional),
+    }).pipe(optional),
+}).annotate({ identifier: "Session.Message.LocationSwitched" });
+export const User = Schema.Struct({
+    ...Base,
+    text: Prompt.fields.text,
+    files: Prompt.fields.files,
+    agents: Prompt.fields.agents,
+    skills: Prompt.fields.skills,
+    type: Schema.tag("user"),
+}).annotate({ identifier: "Session.Message.User" });
+export const Synthetic = Schema.Struct({
+    ...Base,
+    text: Schema.String,
+    description: Schema.String.pipe(optional),
+    type: Schema.tag("synthetic"),
+}).annotate({ identifier: "Session.Message.Synthetic" });
+export const System = Schema.Struct({
+    ...Base,
+    type: Schema.tag("system"),
+    /** The model-facing update text, frozen at emit time. */
+    text: Schema.String,
+    /** A short human-readable summary for transcript display. */
+    description: Schema.String.pipe(optional),
+}).annotate({ identifier: "Session.Message.System" });
+export const Skill = Schema.Struct({
+    ...Base,
+    type: Schema.tag("skill"),
+    skill: SkillSchema.ID,
+    name: SkillSchema.Name,
+    text: Schema.String,
+}).annotate({ identifier: "Session.Message.Skill" });
+export const Shell = Schema.Struct({
+    ...Base,
+    type: Schema.tag("shell"),
+    shellID: ShellSchema.ID,
+    command: Schema.String,
+    status: ShellSchema.Status,
+    exit: Schema.Number.pipe(optional),
+    output: ShellSchema.Output.pipe(optional),
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        completed: DateTimeUtcFromMillis.pipe(optional),
+    }),
+}).annotate({ identifier: "Session.Message.Shell" });
+export const ToolStateStreaming = Schema.Struct({
+    status: Schema.tag("streaming"),
+    input: Schema.String,
+}).annotate({ identifier: "Session.Message.ToolState.Streaming" });
+export const ToolStateRunning = Schema.Struct({
+    status: Schema.tag("running"),
+    input: Schema.Record(Schema.String, Schema.Unknown),
+    metadata: Schema.Record(Schema.String, Schema.Json),
+}).annotate({ identifier: "Session.Message.ToolState.Running" });
+export const ToolStateCompleted = Schema.Struct({
+    status: Schema.tag("completed"),
+    input: Schema.Record(Schema.String, Schema.Unknown),
+    content: Schema.NonEmptyArray(Content),
+    metadata: Schema.Record(Schema.String, Schema.Json).pipe(optional),
+}).annotate({ identifier: "Session.Message.ToolState.Completed" });
+export const ToolStateError = Schema.Struct({
+    status: Schema.tag("error"),
+    input: Schema.Record(Schema.String, Schema.Unknown),
+    error: SessionError.Error,
+    content: Schema.NonEmptyArray(Content).pipe(optional),
+    metadata: Schema.Record(Schema.String, Schema.Json).pipe(optional),
+}).annotate({ identifier: "Session.Message.ToolState.Error" });
+export const ToolState = Schema.Union([ToolStateStreaming, ToolStateRunning, ToolStateCompleted, ToolStateError]).pipe(Schema.toTaggedUnion("status"));
+export const AssistantTool = Schema.Struct({
+    type: Schema.tag("tool"),
+    id: Schema.String,
+    name: Schema.String,
+    executed: Schema.Boolean.pipe(optional),
+    providerState: ProviderState.pipe(optional),
+    providerResultState: ProviderState.pipe(optional),
+    state: ToolState,
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        ran: DateTimeUtcFromMillis.pipe(optional),
+        completed: DateTimeUtcFromMillis.pipe(optional),
+    }),
+}).annotate({ identifier: "Session.Message.Assistant.Tool" });
+export const AssistantText = Schema.Struct({
+    type: Schema.tag("text"),
+    text: Schema.String,
+    state: ProviderState.pipe(optional),
+}).annotate({ identifier: "Session.Message.Assistant.Text" });
+export const AssistantReasoning = Schema.Struct({
+    type: Schema.tag("reasoning"),
+    text: Schema.String,
+    state: ProviderState.pipe(optional),
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        completed: DateTimeUtcFromMillis.pipe(optional),
+    }).pipe(optional),
+}).annotate({ identifier: "Session.Message.Assistant.Reasoning" });
+export const AssistantContent = Schema.Union([AssistantText, AssistantReasoning, AssistantTool]).pipe(Schema.toTaggedUnion("type"));
+export const AssistantContentEncoded = Schema.toEncoded(AssistantContent).annotate({
+    identifier: "Session.Message.AssistantContent.Encoded",
+});
+export const AssistantRetry = Schema.Struct({
+    attempt: PositiveInt,
+    at: DateTimeUtcFromMillis,
+    error: SessionError.Error,
+}).annotate({ identifier: "Session.Message.Assistant.Retry" });
+export const Assistant = Schema.Struct({
+    ...Base,
+    type: Schema.tag("assistant"),
+    agent: Agent.ID,
+    model: Model.Ref,
+    content: AssistantContent.pipe(Schema.Array),
+    snapshot: Schema.Struct({
+        start: Snapshot.ID.pipe(optional),
+        end: Snapshot.ID.pipe(optional),
+        files: Schema.Array(RelativePath).pipe(optional),
+    }).pipe(optional),
+    finish: FinishReason.pipe(optional),
+    rawFinish: Schema.String.pipe(optional),
+    providerState: ProviderState.pipe(optional),
+    cost: Money.USD.pipe(optional),
+    tokens: TokenUsage.Info.pipe(optional),
+    error: SessionError.Error.pipe(optional),
+    retry: AssistantRetry.pipe(optional),
+    time: Schema.Struct({
+        created: DateTimeUtcFromMillis,
+        /** When the provider response body ended, before tool settlement. */
+        streamed: DateTimeUtcFromMillis.pipe(optional),
+        completed: DateTimeUtcFromMillis.pipe(optional),
+    }),
+}).annotate({ identifier: "Session.Message.Assistant" });
+const CompactionBase = { type: Schema.tag("compaction"), ...Base };
+/** Usage of the compaction request itself, not the size of the resulting context. */
+const CompactionUsage = {
+    cost: Money.USD.pipe(optional),
+    tokens: TokenUsage.Info.pipe(optional),
+};
+export const CompactionRunning = Schema.Struct({
+    ...CompactionBase,
+    status: Schema.tag("running"),
+    reason: Schema.Literals(["auto", "manual"]),
+    summary: Schema.String,
+    recent: Schema.String,
+}).annotate({ identifier: "Session.Message.Compaction.Running" });
+export const CompactionCompleted = Schema.Struct({
+    ...CompactionBase,
+    status: Schema.tag("completed"),
+    reason: Schema.Literals(["auto", "manual"]),
+    model: Model.Ref.pipe(optional),
+    providerState: ProviderState.pipe(optional),
+    summary: Schema.String,
+    recent: Schema.String,
+    providerContext: SessionProviderContext.Info.pipe(optional),
+    ...CompactionUsage,
+}).annotate({ identifier: "Session.Message.Compaction.Completed" });
+export const CompactionFailed = Schema.Struct({
+    ...CompactionBase,
+    status: Schema.tag("failed"),
+    reason: Schema.Literals(["auto", "manual"]),
+    error: SessionError.Error,
+    ...CompactionUsage,
+}).annotate({ identifier: "Session.Message.Compaction.Failed" });
+export const Compaction = Schema.Union([CompactionRunning, CompactionCompleted, CompactionFailed]).pipe(Schema.toTaggedUnion("status"), Schema.annotate({ identifier: "Session.Message.Compaction" }));
+export const Info = Schema.Union([
+    AgentSelected,
+    ModelSelected,
+    LocationSwitched,
+    User,
+    Synthetic,
+    System,
+    Skill,
+    Shell,
+    Assistant,
+    Compaction,
+]).annotate({ identifier: "Session.Message.Info" });

package/dist/session-metadata.d.ts

@@ -0,0 +1,8 @@
+import { Schema } from "effect";
+/**
+ * Host-supplied session annotations, durable from creation and opaque to
+ * core. Keys are arbitrary; values must be JSON-serializable. Children and
+ * forks inherit the parent's metadata unless the creator supplies its own.
+ */
+export declare const SessionMetadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type SessionMetadata = typeof SessionMetadata.Type;

package/dist/session-metadata.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+/**
+ * Host-supplied session annotations, durable from creation and opaque to
+ * core. Keys are arbitrary; values must be JSON-serializable. Children and
+ * forks inherit the parent's metadata unless the creator supplies its own.
+ */
+export const SessionMetadata = Schema.Record(Schema.String, Schema.Json).annotate({
+    identifier: "Session.Metadata",
+});

package/dist/session-provider-context.d.ts

@@ -0,0 +1,54 @@
+export * as SessionProviderContext from "./session-provider-context.js";
+import { Schema } from "effect";
+/** Exact producing model/deployment and route identity, never credentials or a connection ID. */
+export interface Provenance extends Schema.Schema.Type<typeof Provenance> {
+}
+export declare const Provenance: Schema.Struct<{
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly provider: Schema.String;
+    readonly modelID: Schema.String;
+    readonly route: Schema.String;
+    readonly protocol: Schema.String;
+    /** Digest of the configured endpoint; raw URLs and query values are not persisted. */
+    readonly endpoint: Schema.String;
+}>;
+/** Core validates the versioned canonical AI Message[] payload on installation and replay. */
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly provenance: Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly provider: Schema.String;
+        readonly modelID: Schema.String;
+        readonly route: Schema.String;
+        readonly protocol: Schema.String;
+        /** Digest of the configured endpoint; raw URLs and query values are not persisted. */
+        readonly endpoint: Schema.String;
+    }>;
+    readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;

package/dist/session-provider-context.js

@@ -0,0 +1,17 @@
+export * as SessionProviderContext from "./session-provider-context.js";
+import { Schema } from "effect";
+import { Provider } from "./provider.js";
+export const Provenance = Schema.Struct({
+    providerID: Provider.ID,
+    provider: Schema.String,
+    modelID: Schema.String,
+    route: Schema.String,
+    protocol: Schema.String,
+    /** Digest of the configured endpoint; raw URLs and query values are not persisted. */
+    endpoint: Schema.String,
+}).annotate({ identifier: "Session.ProviderContext.Provenance" });
+export const Info = Schema.Struct({
+    version: Schema.Literal(1),
+    provenance: Provenance,
+    messages: Schema.Json,
+}).annotate({ identifier: "Session.ProviderContext" });