@kilocode/schema 0.0.0-stage → 0.0.0-v2-9

package/dist/session-message.js

@@ -0,0 +1,234 @@
+export * as SessionMessage from "./session-message.js";
+import { Schema } from "effect";
+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 { 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.isStartingWith("msg_")).pipe(Schema.brand("Session.Message.ID"), Schema.annotate({ identifier: "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 }),
+};
+/**
+ * Provider-owned replay data, keyed by the producing provider's metadata fields and echoed back verbatim. A tool's
+ * result data is merged into its call data, so adapters must not reuse a key with a different value across the two.
+ */
+export const Native = Schema.Record(Schema.String, Schema.Unknown).annotate({
+    identifier: "Session.Message.Native",
+});
+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),
+    native: Native.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,
+    native: Native.pipe(optional),
+}).annotate({ identifier: "Session.Message.Assistant.Text" });
+export const AssistantReasoning = Schema.Struct({
+    type: Schema.tag("reasoning"),
+    text: Schema.String,
+    native: Native.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),
+    /** Step-level native data, such as a provider's reason for blocking a response. */
+    native: Native.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,
+}).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),
+    /** A provider compaction stores its replacement window in `native.messages`, replayed instead of `summary`. */
+    native: Native.pipe(optional),
+    summary: Schema.String,
+    ...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 Idle = Schema.Struct({
+    ...Base,
+    type: Schema.tag("idle"),
+    outcome: Schema.Literals(["succeeded", "failed", "interrupted"]),
+    error: SessionError.Error.pipe(optional),
+}).annotate({ identifier: "Session.Message.Idle" });
+export const Info = Schema.Union([
+    AgentSelected,
+    ModelSelected,
+    LocationSwitched,
+    User,
+    Synthetic,
+    System,
+    Skill,
+    Shell,
+    Assistant,
+    Compaction,
+    Idle,
+]).annotate({ identifier: "Session.Message.Info" });

package/dist/session-metadata.d.ts

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