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

package/dist/session-inbox.js

@@ -0,0 +1,47 @@
+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,
+    time: Schema.Struct({ created: 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" }));

package/dist/session-legacy.d.ts

@@ -0,0 +1,7 @@
+export * as SessionLegacy from "./session-legacy.js";
+/** Upgrades a durable event payload by event type. */
+export declare function event(type: string, data: unknown): unknown;
+/** Upgrades a projected message's data by message type. */
+export declare function message(type: unknown, data: Record<string, unknown>): Record<string, unknown>;
+/** Upgrades complete messages, such as those in an exported session, before decoding. */
+export declare function messages(values: ReadonlyArray<unknown>): unknown[];

package/dist/session-legacy.js

@@ -0,0 +1,118 @@
+export * as SessionLegacy from "./session-legacy.js";
+/**
+ * Storage and wire compatibility for current-architecture data written before v2.1 (not V1 contracts). Native data
+ * was then named `state` or `providerState`, a tool's result native data `resultState` or `providerResultState`,
+ * summary compactions stored the text of the messages they kept in `recent`, and provider compactions stored their
+ * replacement window in `providerContext`. Stored events, projected messages, and exported transcripts keep whichever
+ * shape they were written with, so these upgrade them before decoding.
+ */
+const renames = {
+    "session.text.ended": ["state", "native"],
+    "session.reasoning.started": ["state", "native"],
+    "session.reasoning.ended": ["state", "native"],
+    "session.tool.called": ["state", "native"],
+    "session.step.ended": ["providerState", "native"],
+    "session.step.failed": ["providerState", "native"],
+    "session.tool.success": ["resultState", "native"],
+    "session.tool.failed": ["resultState", "native"],
+};
+/** Upgrades a durable event payload by event type. */
+export function event(type, data) {
+    if (!isRecord(data))
+        return data;
+    if (type === "session.message.content.updated")
+        return content(data);
+    // Messages carry a legacy compaction's kept text; its events have no reader for it.
+    if (type === "session.compaction.started")
+        return omit(data, "recent");
+    if (type === "session.compaction.ended")
+        return providerContext(omit(rename(data, "providerState", "native"), "recent"));
+    const entry = renames[type];
+    return entry ? rename(data, entry[0], entry[1]) : data;
+}
+/** Upgrades a projected message's data by message type. */
+export function message(type, data) {
+    if (type === "assistant")
+        return content(rename(data, "providerState", "native"));
+    if (type === "compaction")
+        return providerContext(recent(rename(data, "providerState", "native")));
+    return data;
+}
+/** Upgrades complete messages, such as those in an exported session, before decoding. */
+export function messages(values) {
+    return values.map((value) => (isRecord(value) ? message(value.type, value) : value));
+}
+function content(data) {
+    if (!Array.isArray(data.content))
+        return data;
+    return { ...data, content: data.content.map(part) };
+}
+function part(value) {
+    if (!isRecord(value))
+        return value;
+    if (value.type === "text" || value.type === "reasoning")
+        return rename(value, "state", "native");
+    // A tool part's own `state` is its lifecycle status, not native data.
+    if (value.type === "tool")
+        return toolResult(rename(value, "providerState", "native"));
+    return value;
+}
+/** Kept text a summary compaction stored before it referenced `metadata.keepID`; replay still reads it. */
+function recent(data) {
+    const text = data.recent;
+    const rest = omit(data, "recent");
+    if (typeof text !== "string" || !text)
+        return rest;
+    const metadata = isRecord(rest.metadata) ? rest.metadata : {};
+    return { ...rest, metadata: { recent: text, ...metadata } };
+}
+/** The window moves to `native.messages`; the `native` stored beside it was never replayed. */
+function providerContext(data) {
+    const context = data.providerContext;
+    const rest = omit(data, "providerContext");
+    if (!isRecord(context))
+        return rest;
+    return {
+        ...rest,
+        native: { messages: Array.isArray(context.messages) ? context.messages.map(media) : context.messages },
+    };
+}
+/** Before 2.0.15, window media parts stored `mediaType` and base64 `data` directly. */
+function media(message) {
+    if (!isRecord(message) || !Array.isArray(message.content))
+        return message;
+    return {
+        ...message,
+        content: message.content.map((part) => {
+            if (!isRecord(part) || part.type !== "media" || part.media !== undefined || typeof part.data !== "string")
+                return part;
+            const { mediaType, data, ...rest } = part;
+            return { ...rest, media: { source: { type: "base64", data, mediaType } } };
+        }),
+    };
+}
+function omit(value, key) {
+    if (!(key in value))
+        return value;
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+// Result data now merges into the tool's single `native`, as projection does for current result events.
+function toolResult(value) {
+    if (!("providerResultState" in value))
+        return value;
+    const { providerResultState, ...rest } = value;
+    if (!isRecord(providerResultState))
+        return rest;
+    return { ...rest, native: { ...(isRecord(rest.native) ? rest.native : {}), ...providerResultState } };
+}
+// The current name wins when a payload carries both.
+function rename(value, from, to) {
+    if (!(from in value))
+        return value;
+    const { [from]: moved, ...rest } = value;
+    return to in rest ? rest : { ...rest, [to]: moved };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}