eve 0.83.2 → 0.84.0

package/dist/src/protocol/session-events/schemas.d.ts

@@ -0,0 +1,320 @@
+import { z } from "#compiled/zod/index.js";
+export declare const FACT_SCHEMAS: {
+    "call.requested": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"call.requested">;
+    }, z.core.$strip>;
+    "call.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"call.settled">;
+    }, z.core.$strip>;
+    "call.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"call.started">;
+    }, z.core.$strip>;
+    "child.opened": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"child.opened">;
+    }, z.core.$strip>;
+    "child.sent": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"child.sent">;
+    }, z.core.$strip>;
+    "content.completed": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"content.completed">;
+    }, z.core.$strip>;
+    "context.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"context.settled">;
+    }, z.core.$strip>;
+    "context.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"context.started">;
+    }, z.core.$strip>;
+    "delivery.admitted": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"delivery.admitted">;
+    }, z.core.$strip>;
+    "delivery.consumed": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"delivery.consumed">;
+    }, z.core.$strip>;
+    "delivery.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"delivery.settled">;
+    }, z.core.$strip>;
+    "interaction.opened": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"interaction.opened">;
+    }, z.core.$strip>;
+    "interaction.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"interaction.settled">;
+    }, z.core.$strip>;
+    "model.requested": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"model.requested">;
+    }, z.core.$strip>;
+    "model.retried": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"model.retried">;
+    }, z.core.$strip>;
+    "model.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"model.settled">;
+    }, z.core.$strip>;
+    "model.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"model.started">;
+    }, z.core.$strip>;
+    "response.admitted": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"response.admitted">;
+    }, z.core.$strip>;
+    "response.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"response.settled">;
+    }, z.core.$strip>;
+    "response.submitted": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"response.submitted">;
+    }, z.core.$strip>;
+    "session.ended": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"session.ended">;
+    }, z.core.$strip>;
+    "session.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"session.started">;
+    }, z.core.$strip>;
+    "task.ended": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"task.ended">;
+    }, z.core.$strip>;
+    "task.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"task.started">;
+    }, z.core.$strip>;
+    "turn.paused": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"turn.paused">;
+    }, z.core.$strip>;
+    "turn.settled": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"turn.settled">;
+    }, z.core.$strip>;
+    "turn.started": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"turn.started">;
+    }, z.core.$strip>;
+    "usage.recorded": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"usage.recorded">;
+    }, z.core.$strip>;
+};
+export declare const PROGRESS_SCHEMAS: {
+    "call.input": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"call.input">;
+    }, z.core.$strip>;
+    "call.progress": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"call.progress">;
+    }, z.core.$strip>;
+    "content.delta": z.ZodObject<{
+        data: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+        scope: z.ZodOptional<z.ZodObject<{
+            changeId: z.ZodOptional<z.ZodString>;
+            runId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            turnId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        type: z.ZodLiteral<"content.delta">;
+    }, z.core.$strip>;
+};
+/**
+ * Checks one fact or progress record of a known type against its schema, and returns what's
+ * wrong, or `undefined`. Records of unknown types pass: readers ignore them.
+ */
+export declare function schemaViolation(record: unknown, kind: "fact" | "progress"): string | undefined;

package/dist/src/protocol/session-events/schemas.js

@@ -0,0 +1 @@
+import{callProgressSchemas,callSchemas}from"./families/call.js";import{childSchemas}from"./families/child.js";import{contentProgressSchemas,contentSchemas}from"./families/content.js";import{contextSchemas}from"./families/context.js";import{deliverySchemas}from"./families/delivery.js";import{interactionSchemas}from"./families/interaction.js";import{modelSchemas}from"./families/model.js";import{responseSchemas}from"./families/response.js";import{sessionSchemas}from"./families/session.js";import{taskSchemas}from"./families/task.js";import{turnSchemas}from"./families/turn.js";import{usageSchemas}from"./families/usage.js";import{z}from"#compiled/zod/index.js";const FACT_SCHEMAS={...sessionSchemas,...deliverySchemas,...turnSchemas,...modelSchemas,...contentSchemas,...callSchemas,...taskSchemas,...interactionSchemas,...responseSchemas,...childSchemas,...contextSchemas,...usageSchemas},PROGRESS_SCHEMAS={...contentProgressSchemas,...callProgressSchemas};function schemaViolation(e,t){let n=typeof e==`object`&&e?e.type:void 0;if(typeof n!=`string`)return`A ${t} has no type.`;let r=(t===`fact`?FACT_SCHEMAS:PROGRESS_SCHEMAS)[n];if(r===void 0)return;let i=r.safeParse(e);return i.success?void 0:`${n}: ${z.prettifyError(i.error)}`}export{FACT_SCHEMAS,PROGRESS_SCHEMAS,schemaViolation};

package/dist/src/protocol/session-http.d.ts

@@ -0,0 +1,7 @@
+export declare const EVE_SESSION_ID_HEADER = "x-eve-session-id";
+export declare const EVE_STREAM_FORMAT_HEADER = "x-eve-stream-format";
+export declare const EVE_STREAM_TAIL_INDEX_HEADER = "x-eve-stream-tail-index";
+export declare const EVE_STREAM_VERSION_HEADER = "x-eve-stream-version";
+export declare const EVE_MESSAGE_STREAM_CONTENT_TYPE = "application/x-ndjson; charset=utf-8";
+export declare const EVE_MESSAGE_STREAM_FORMAT = "ndjson";
+export declare const EVE_MESSAGE_STREAM_VERSION = "27";

package/dist/src/protocol/session-http.js

@@ -0,0 +1 @@
+const EVE_SESSION_ID_HEADER=`x-eve-session-id`,EVE_STREAM_FORMAT_HEADER=`x-eve-stream-format`,EVE_STREAM_TAIL_INDEX_HEADER=`x-eve-stream-tail-index`,EVE_STREAM_VERSION_HEADER=`x-eve-stream-version`,EVE_MESSAGE_STREAM_CONTENT_TYPE=`application/x-ndjson; charset=utf-8`,EVE_MESSAGE_STREAM_FORMAT=`ndjson`,EVE_MESSAGE_STREAM_VERSION=`27`;export{EVE_MESSAGE_STREAM_CONTENT_TYPE,EVE_MESSAGE_STREAM_FORMAT,EVE_MESSAGE_STREAM_VERSION,EVE_SESSION_ID_HEADER,EVE_STREAM_FORMAT_HEADER,EVE_STREAM_TAIL_INDEX_HEADER,EVE_STREAM_VERSION_HEADER};

package/dist/src/protocol/session-lines.d.ts

@@ -0,0 +1,19 @@
+import type { StoredLine } from "#protocol/session-events/envelope.js";
+import type { SessionEvent, SessionStreamEvent } from "#protocol/session-event.js";
+/** True for a record this version knows: a v27 fact or progress type. */
+export declare function isKnownRecordType(type: unknown): boolean;
+/**
+ * The lines one publication writes: each run of facts as one commit, each progress record as its
+ * own line, in order.
+ */
+export declare function linesOf(events: readonly SessionEvent[], at: string): StoredLine<SessionEvent, SessionEvent>[];
+/**
+ * The events a line carries, each with its position and time; a progress record takes
+ * `progressAt`, the time of the latest commit. Records of types this version doesn't know are
+ * skipped, as every reader skips them.
+ */
+export declare function eventsOfLine(line: StoredLine, position: number, progressAt: string): SessionStreamEvent[];
+/** Reads events from consecutive lines, keeping the time progress records inherit. */
+export declare function createEventReader(progressAt?: string): {
+    read(line: StoredLine, position: number): SessionStreamEvent[];
+};

package/dist/src/protocol/session-lines.js

@@ -0,0 +1 @@
+import{isFactType,isProgressType}from"#protocol/session-events/catalog.js";function isKnownRecordType(e){return isFactType(e)||isProgressType(e)}function linesOf(e,t){let n=[],r=[],flush=()=>{r.length!==0&&(n.push({at:t,facts:r}),r=[])};for(let t of e)isProgressType(t.type)?(flush(),n.push({progress:t})):r.push(t);return flush(),n}function eventsOfLine(e,t,n){let r=`facts`in e?e.facts:[e.progress],i=`facts`in e?e.at:n,a=[];r.forEach((e,n)=>{if(typeof e!=`object`||!e)return;let r=e;isKnownRecordType(r.type)&&a.push({...r,meta:{at:i,endOfLine:!1,position:{index:n,line:t}}})});let o=a.at(-1);return o!==void 0&&(a[a.length-1]={...o,meta:{...o.meta,endOfLine:!0}}),a}function createEventReader(e=new Date(0).toISOString()){let t=e;return{read(e,n){return`facts`in e&&(t=e.at),eventsOfLine(e,n,t)}}}export{createEventReader,eventsOfLine,isKnownRecordType,linesOf};

package/dist/src/protocol/session-projection/fold.d.ts

@@ -0,0 +1,75 @@
+import type { StoredLine } from "#protocol/session-events/envelope.js";
+import type { SessionPreviews, SessionView } from "./tables.js";
+/**
+ * How much a fold keeps. `complete` keeps everything, for clients and history reads.
+ * `operational` keeps the session, everything still open and its ownership ancestors, what the
+ * latest line touched, the latest turn's reply, and the rows of the latest turn and of any turn
+ * whose calls still work, for
+ * server checkpoints and observers; it drops the rest when the next line arrives. A channel shows
+ * what a turn did from its rows, so they stay until the next turn starts, or its tasks finish.
+ */
+export type Retention = "complete" | "operational";
+export interface FoldOptions {
+    readonly retention?: Retention;
+    /** In operational retention, rows to keep after they close, such as ones execution still reads. */
+    readonly keep?: (table: TableName, id: string) => boolean;
+}
+export type TableName = "deliveries" | "turns" | "runs" | "parts" | "calls" | "tasks" | "interactions" | "responses" | "children" | "changes";
+export declare function emptySessionView(): SessionView;
+export declare function emptyPreviews(): SessionPreviews;
+/**
+ * Folds the line at `position` into `view`, and its progress or completions into `previews`.
+ * A line at or before the view's position was already folded and is skipped, which absorbs
+ * reconnect overlap and merged caches.
+ */
+export declare function foldLine(view: SessionView, line: StoredLine, position: number, options?: FoldOptions & {
+    readonly previews?: SessionPreviews;
+}): void;
+/** Folds lines read from `startPosition` on, for a reader that holds a whole range. */
+export declare function foldLines(view: SessionView, lines: Iterable<StoredLine>, startPosition: number, options?: FoldOptions & {
+    readonly previews?: SessionPreviews;
+}): void;
+/** One event as a reader received it back: the record, and where its line put it. */
+export interface ReceivedEvent {
+    readonly type: string;
+    readonly data?: unknown;
+    readonly scope?: unknown;
+    readonly meta: {
+        readonly position: {
+            readonly line: number;
+            readonly index: number;
+        };
+        readonly at: string;
+        readonly endOfLine?: boolean;
+    };
+}
+/**
+ * Folds events as a reader received them back, regrouped into their lines by position. A line
+ * folds whole, once its last record has arrived: the events of a line still arriving are
+ * returned unfolded, to pass again with the rest. Lines the view already folded are skipped, so
+ * replayed overlap folds once.
+ */
+export declare function foldEvents<TEvent extends ReceivedEvent>(view: SessionView, events: readonly TEvent[], options?: FoldOptions & {
+    readonly previews?: SessionPreviews;
+}): readonly TEvent[];
+/** The tables a complete read of `events` folds into, with each part's and call's previews. */
+export declare function viewOfEvents(events: readonly ReceivedEvent[]): {
+    readonly view: SessionView;
+    readonly previews: SessionPreviews;
+};
+/**
+ * A copy of a view that folding can change without changing `view`. Rows are replaced, never
+ * edited, so copying the tables is enough: a reader that keeps every state, such as a UI's
+ * reducer, copies before each fold instead of cloning every row.
+ */
+export declare function copyView(view: SessionView): SessionView;
+/**
+ * Folds one event as a reader received it, for a reader that updates on each event rather than
+ * on each line. Facts apply in order within a line, so folding a line event by event leaves the
+ * same tables; the view's position moves past the line with its last event. Events of a line
+ * the view already passed are skipped.
+ */
+export declare function foldReceivedEvent(view: SessionView, event: {
+    readonly type: string;
+    readonly meta?: Partial<ReceivedEvent["meta"]>;
+}, previews?: SessionPreviews): void;

package/dist/src/protocol/session-projection/fold.js

@@ -0,0 +1 @@
+import{FACT_CATALOG,isFactType,isProgressType}from"#protocol/session-events/catalog.js";import{isOpen,parentOf,refOf,tableOf,turnOf}from"#protocol/session-projection/tree.js";import{isObject}from"#protocol/session-events/json.js";const ZERO={cacheReadTokens:0,cacheWriteTokens:0,inputTokens:0,outputTokens:0};function dictionary(e){return Object.assign(Object.create(null),e)}function emptySessionView(){return{calls:dictionary(),changes:dictionary(),children:dictionary(),deliveries:dictionary(),interactions:dictionary(),parts:dictionary(),position:0,responses:dictionary(),runs:dictionary(),session:{status:`new`,turnCount:0},tasks:dictionary(),turns:dictionary(),usage:{byKind:dictionary(),total:ZERO}}}function emptyPreviews(){return{calls:dictionary(),parts:dictionary()}}function foldLine(e,t,n,r={}){let i=e;if(n<i.position)return;r.retention===`operational`&&prune(i,r.keep),i.position=n+1;let a=r.previews;if(`progress`in t){a!==void 0&&foldProgress(i,a,t.progress);return}if(Array.isArray(t.facts))for(let e of t.facts)foldFact(i,a,e,{at:t.at,position:n})}function foldLines(e,t,n,r={}){let i=n;for(let n of t)foldLine(e,n,i,r),i+=1}function foldEvents(e,t,n={}){let r=0;for(;r<t.length;){let i=t[r].meta.position.line,a=r+1;for(;a<t.length&&t[a].meta.position.line===i;)a+=1;let o=t.slice(r,a);if(o.at(-1).meta.endOfLine===!1)return t.slice(r);let s=o[0];foldLine(e,o.length===1&&isProgressType(s.type)?{progress:s}:{at:s.meta.at,facts:o},i,n),r=a}return[]}function viewOfEvents(e){let t=emptySessionView(),n=emptyPreviews();return foldEvents(t,e,{previews:n}),{previews:n,view:t}}function copyView(e){return{...e,calls:dictionary(e.calls),changes:dictionary(e.changes),children:dictionary(e.children),deliveries:dictionary(e.deliveries),interactions:dictionary(e.interactions),parts:dictionary(e.parts),responses:dictionary(e.responses),runs:dictionary(e.runs),tasks:dictionary(e.tasks),turns:dictionary(e.turns)}}function foldReceivedEvent(e,t,n){let r=e,i=t.meta?.position?.line??r.position;if(i<r.position)return;let a=n;isFactType(t.type)?foldFact(r,a,t,{at:t.meta?.at??``,position:i}):a!==void 0&&isProgressType(t.type)&&foldProgress(r,a,t),t.meta?.endOfLine!==!1&&(r.position=i+1)}function foldFact(e,t,n,r){if(typeof n!=`object`||!n)return;let i=n;if(isFactType(i.type)&&i.data!==null&&typeof i.data==`object`&&e.session.status!==`ended`&&(i.type!==`model.requested`&&i.type!==`call.requested`&&i.type!==`child.opened`||isObject(i.data.owner))){if(foldLifecycle(e,i,{introducedAt:r.position,startedAt:r.at},r)){foldSpecifics(e,t,i,r);return}switch(i.type){case`session.started`:{if(e.session.status!==`new`)return;let{parent:t,runtime:n}=i.data;e.session={...e.session,parent:t,runtime:n,startedAt:r.at,status:`open`};return}case`session.ended`:{let{cause:t,error:n,outcome:a}=i.data;if(typeof a!=`string`)return;e.session={...e.session,cause:t,closedAt:r.position,endedAt:r.at,error:n,outcome:a,status:`ended`};return}case`child.sent`:{let{callId:t,childDeliveryId:n,sessionId:r}=i.data,a=e.children[r];if(a===void 0||a.deliveries?.some(e=>e.deliveryId===n))return;e.children[r]={...a,deliveries:[...a.deliveries??[],{callId:t,deliveryId:n}]};return}case`usage.recorded`:{let{kind:t,owner:n,usage:r}=i.data;if(typeof r!=`object`||!r||(e.usage=addToTotals(e.usage,t,r),!isObject(n)))return;if(`runId`in n){let t=e.runs[n.runId];t!==void 0&&(e.runs[t.runId]={...t,usage:addUsage(t.usage,r)})}else if(`callId`in n){let t=e.calls[n.callId];t!==void 0&&(e.calls[t.callId]={...t,usage:addUsage(t.usage,r)})}return}}}}const LIFECYCLE={"call.requested":{status:`requested`,table:`calls`},"call.settled":{status:`settled`,table:`calls`},"call.started":{from:`requested`,status:`running`,table:`calls`},"child.opened":{table:`children`},"content.completed":{table:`parts`},"context.settled":{status:`settled`,table:`changes`},"context.started":{status:`running`,table:`changes`},"delivery.admitted":{status:`admitted`,table:`deliveries`},"delivery.consumed":{from:`admitted`,omit:[`history`],status:`consumed`,table:`deliveries`},"delivery.settled":{status:`settled`,table:`deliveries`},"interaction.opened":{status:`open`,table:`interactions`},"interaction.settled":{status:`settled`,table:`interactions`},"model.requested":{status:`requested`,table:`runs`},"model.settled":{status:`settled`,table:`runs`},"model.started":{status:`running`,table:`runs`},"response.admitted":{from:`submitted`,status:`admitted`,table:`responses`},"response.settled":{status:`settled`,table:`responses`},"response.submitted":{status:`submitted`,table:`responses`},"task.ended":{status:`ended`,table:`tasks`},"task.started":{status:`running`,table:`tasks`},"turn.settled":{rename:{cause:`endedBy`},status:`settled`,table:`turns`},"turn.started":{omit:[`trace`],status:`running`,table:`turns`}},FOLD_FIELDS=new Set([`introducedAt`,`startedAt`,`closedAt`,`endedAt`,`consumedAt`,`step`,`runs`,`status`]);function foldLifecycle(e,t,n,r){let i=LIFECYCLE[t.type];if(i===void 0)return!1;let{idField:a,role:o}=FACT_CATALOG[t.type],s=Object.fromEntries(Object.entries(t.data).flatMap(([e,t])=>i.omit?.includes(e)===!0||FOLD_FIELDS.has(e)?[]:[[i.rename?.[e]??e,t]])),c=s[a];if(typeof c!=`string`)return!1;let l=e[i.table],u=l[c],d=i.status===void 0?{}:{status:i.status},closed=e=>e.status===`settled`||e.status===`ended`;switch(o){case`introduces`:case`complete`:return u===void 0&&(l[c]={...n,...s,...d},!0);case`updates`:return u===void 0||(i.from===void 0?closed(u):u.status!==i.from)?!1:(l[c]={...u,...s,...d},!0);case`terminal`:return u===void 0||closed(u)||typeof s.outcome!=`string`?!1:(l[c]={...u,...s,closedAt:r.position,endedAt:r.at,...d},!0);default:return!1}}function foldSpecifics(e,t,n,r){switch(n.type){case`delivery.consumed`:{let t=e.deliveries[n.data.deliveryId];e.deliveries[t.deliveryId]={...t,consumedAt:r.position};return}case`turn.started`:e.session={...e.session,latestTurnId:n.data.turnId,turnCount:e.session.turnCount+1},delete e.selection;return;case`model.requested`:{let{owner:t,runId:r}=n.data,i=`turnId`in t?e.turns[t.turnId]:void 0;if(i===void 0)return;let a=i.runs??0;e.turns[i.turnId]={...i,runs:a+1},e.runs[r]={...e.runs[r],step:a};return}case`model.settled`:t!==void 0&&dropRunPreviews(e,t,n.data.runId);return;case`call.requested`:case`call.settled`:t!==void 0&&delete t.calls[n.data.callId];return;case`content.completed`:{let{partId:r,phase:i,runId:a}=n.data;t!==void 0&&delete t.parts[r];let o=e.runs[a]?.owner,s=o!==void 0&&`turnId`in o?e.turns[o.turnId]:void 0;if(i===`reply`&&s!==void 0&&s.status!==`settled`){let t=(s.reply??[]).filter(t=>e.parts[t]?.runId===a);e.turns[s.turnId]={...s,reply:[...t,r]}}return}case`context.settled`:{let{outcome:t,selects:r}=n.data;t===`completed`&&`selects`in n.data&&r!==void 0&&(e.selection=r);return}}}function foldProgress(e,t,n){if(typeof n!=`object`||!n)return;let r=n;if(isProgressType(r.type)&&r.data!==null&&typeof r.data==`object`&&e.session.status!==`ended`)switch(r.type){case`content.delta`:{let{delta:n,kind:i,partId:a}=r.data;if(e.parts[a]!==void 0||typeof n!=`string`)return;let o=t.parts[a];o===void 0?i!==void 0&&(t.parts[a]={kind:i,partId:a,runId:r.scope?.runId,text:n}):t.parts[a]={...o,text:o.text+n};return}case`call.input`:{let{callId:n,delta:i,kind:a,name:o}=r.data;if(e.calls[n]!==void 0||typeof i!=`string`)return;let s=t.calls[n];if(s!==void 0)t.calls[n]={...s,input:s.input+i};else if(o!==void 0){let e={callId:n,input:i,name:o,runId:r.scope?.runId};t.calls[n]=a===void 0?e:{...e,kind:a}}return}case`call.progress`:{let{callId:n,output:i,label:a}=r.data,o=e.calls[n];if(o===void 0||o.status===`settled`)return;let s=t.calls[n];t.calls[n]={callId:n,input:s?.input??``,name:o.capability.name,output:i,runId:`runId`in o.owner?o.owner.runId:void 0,...a!==void 0&&{label:a}};return}}}function dropRunPreviews(e,t,n){for(let[e,r]of Object.entries(t.parts))r.runId===n&&delete t.parts[e];for(let[r,i]of Object.entries(t.calls))i.runId===n&&e.calls[r]===void 0&&delete t.calls[r]}function prune(e,t){let n=new Set,pinPath=t=>{let r=t===void 0?[]:[t];for(;r.length>0;){let t=r.pop(),i=`${tableOf(t.family)}:${t.id}`;if(n.has(i))continue;n.add(i);let a=parentOf(e,t);a!==void 0&&r.push(a);let o=t.family===`call`?refOf(e.calls[t.id]?.owner):void 0;o!==void 0&&r.push(o)}};for(let t of[`call`,`run`,`change`,`interaction`,`delivery`])for(let n of Object.keys(e[tableOf(t)]))isOpen(e,{family:t,id:n})&&pinPath({family:t,id:n});for(let t of Object.values(e.responses))t.status!==`settled`&&(pinPath({family:`response`,id:t.responseId}),pinPath({family:`delivery`,id:t.deliveryId}));let r=liveTurns(e),i=e.session.latestTurnId;for(let t of(i===void 0?void 0:e.turns[i]?.reply)??[])n.add(`parts:${t}`);let retained=(i,a)=>{if(n.has(`${tableOf(i)}:${a}`)||t?.(tableOf(i),a)===!0)return!0;let o=i===`part`?void 0:turnOf(e,{family:i,id:a});return o!==void 0&&r.has(o)},dropWhere=(e,t,n)=>{for(let[r,i]of Object.entries(t))n(i)&&!retained(e,r)&&delete t[r]};dropWhere(`delivery`,e.deliveries,e=>e.status===`settled`),dropWhere(`turn`,e.turns,e=>e.status===`settled`),dropWhere(`run`,e.runs,e=>e.status===`settled`),dropWhere(`part`,e.parts,()=>!0),dropWhere(`call`,e.calls,e=>e.status===`settled`),dropWhere(`task`,e.tasks,e=>e.status===`ended`),dropWhere(`interaction`,e.interactions,e=>e.status===`settled`),dropWhere(`response`,e.responses,e=>e.status===`settled`),dropWhere(`change`,e.changes,e=>e.status===`settled`);for(let[t,n]of Object.entries(e.children))(`callId`in n.owner?e.calls[n.owner.callId]:e.tasks[n.owner.taskId])===void 0?delete e.children[t]:n.deliveries!==void 0&&(e.children[t]={...n,deliveries:void 0});for(let t of Object.values(e.calls))t.status===`settled`&&!n.has(`calls:${t.callId}`)&&withholdLarge(e,t)}function liveTurns(e){let t=new Set;e.session.latestTurnId!==void 0&&t.add(e.session.latestTurnId);for(let n of Object.values(e.calls)){if(n.status===`settled`)continue;let r=turnOf(e,{family:`call`,id:n.callId});r!==void 0&&t.add(r)}return t}const MAX_KEPT_VALUE_LENGTH=16384;function withholdLarge(e,t){let size=e=>e===void 0?0:JSON.stringify(e)?.length??0,n=size(t.input),r=size(t.output);if(n<=MAX_KEPT_VALUE_LENGTH&&r<=MAX_KEPT_VALUE_LENGTH)return;let{input:i,output:a,...o}=t;e.calls[t.callId]={...o,...n<=MAX_KEPT_VALUE_LENGTH?{input:i}:{inputRef:{size:n,mediaType:`application/json`}},...r<=MAX_KEPT_VALUE_LENGTH?a===void 0?{}:{output:a}:{outputRef:{size:r,mediaType:`application/json`}}}}function addUsage(e,t){if(e===void 0)return t;let n={cacheReadTokens:e.cacheReadTokens+t.cacheReadTokens,cacheWriteTokens:e.cacheWriteTokens+t.cacheWriteTokens,inputTokens:e.inputTokens+t.inputTokens,outputTokens:e.outputTokens+t.outputTokens};return(e.costUsd!==void 0||t.costUsd!==void 0)&&(n.costUsd=(e.costUsd??0)+(t.costUsd??0)),n}function addToTotals(e,t,n){return{byKind:dictionary({...e.byKind,[t]:addUsage(e.byKind[t],n)}),total:addUsage(e.total,n)}}export{copyView,emptyPreviews,emptySessionView,foldEvents,foldLine,foldLines,foldReceivedEvent,viewOfEvents};

package/dist/src/protocol/session-projection/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./fold.js";
+export type { RequestStatus } from "./request-status.js";
+export { activeTurn, activity, callLabel, callOutputSource, callState, conversation, failure, idle, openInteractions, queue, reply, tasks, waiting, type Activity, type CallState, type Waiting, } from "./selectors.js";
+export type * from "./tables.js";

package/dist/src/protocol/session-projection/index.js

@@ -0,0 +1 @@
+import{copyView,emptyPreviews,emptySessionView,foldEvents,foldLine,foldLines,foldReceivedEvent,viewOfEvents}from"./fold.js";import{activeTurn,activity,callLabel,callOutputSource,callState,conversation,failure,idle,openInteractions,queue,reply,tasks,waiting}from"./selectors.js";export{activeTurn,activity,callLabel,callOutputSource,callState,conversation,copyView,emptyPreviews,emptySessionView,failure,foldEvents,foldLine,foldLines,foldReceivedEvent,idle,openInteractions,queue,reply,tasks,viewOfEvents,waiting};

package/dist/src/protocol/session-projection/observations.d.ts

@@ -0,0 +1,150 @@
+import type { ErrorInfo, JsonValue, Principal, Usage, UserPart, ValueReference } from "#protocol/session-events/envelope.js";
+import type { CapabilityKind, CallOutcome, ClearedBy } from "#protocol/session-events/families/call.js";
+import type { DeliveryOutcome, DeliverySource } from "#protocol/session-events/families/delivery.js";
+import type { TurnOutcome } from "#protocol/session-events/families/turn.js";
+import type { TaskOutcome } from "#protocol/session-events/families/task.js";
+import type { ModelOutcome } from "#protocol/session-events/families/model.js";
+import type { ContentKind, ContentPhase } from "#protocol/session-events/families/content.js";
+import type { RuntimeIdentity, SessionOutcome } from "#protocol/session-events/families/session.js";
+import type { Interaction } from "#protocol/session-projection/reader.js";
+import type { CallState } from "./selectors.js";
+/** Wall-clock times reported by the facts, not storage positions. */
+export interface ObservationTiming {
+    readonly startedAt?: string;
+    readonly endedAt?: string;
+}
+/** Display-ready call state and resolved ownership; no table joins are required. */
+export type CallObservation = ObservationTiming & {
+    readonly callId: string;
+    readonly name: string;
+    readonly kind: CapabilityKind;
+    readonly label: string;
+    readonly runId?: string;
+    readonly turnId?: string;
+    readonly taskId?: string;
+    readonly input?: JsonValue;
+    readonly inputRef?: ValueReference;
+    readonly output?: JsonValue;
+    readonly outputRef?: ValueReference;
+    readonly outcome?: CallOutcome;
+    readonly reason?: string;
+    readonly clearedBy?: ClearedBy;
+    readonly usage?: Usage;
+} & ({
+    readonly state: "failed";
+    readonly error: ErrorInfo;
+} | {
+    readonly state: Exclude<CallState, "failed">;
+    readonly error?: ErrorInfo;
+});
+export interface CallFilter {
+    readonly kind?: CapabilityKind;
+    readonly name?: string;
+    readonly turnId?: string;
+    readonly runId?: string;
+    readonly taskId?: string;
+}
+export interface TurnObservation extends ObservationTiming {
+    readonly turnId: string;
+    readonly status: "running" | "settled";
+    readonly outcome?: TurnOutcome;
+    readonly error?: ErrorInfo;
+}
+export interface DeliveryObservation extends ObservationTiming {
+    readonly deliveryId: string;
+    readonly status: "admitted" | "consumed" | "settled";
+    readonly turnId?: string;
+    readonly outcome?: DeliveryOutcome;
+    readonly reason?: string;
+    readonly source?: DeliverySource;
+    readonly principal?: Principal;
+    readonly parts?: readonly UserPart[];
+}
+export interface TaskObservation extends ObservationTiming {
+    readonly taskId: string;
+    readonly callId: string;
+    readonly name: string;
+    readonly kind: string;
+    readonly status: "running" | "ended";
+    readonly outcome?: TaskOutcome;
+    readonly reason?: string;
+    readonly error?: ErrorInfo;
+}
+export interface RunObservation extends ObservationTiming {
+    readonly runId: string;
+    readonly turnId?: string;
+    readonly status: "requested" | "running" | "settled";
+    readonly modelId?: string;
+    readonly outcome?: ModelOutcome;
+    readonly finishReason?: string;
+    readonly error?: ErrorInfo;
+    readonly usage?: Usage;
+}
+export interface ContentObservation extends ObservationTiming {
+    readonly partId: string;
+    readonly runId: string;
+    readonly kind: ContentKind;
+    readonly phase: ContentPhase;
+    readonly value?: JsonValue;
+    readonly valueRef?: ValueReference;
+    readonly interrupted?: true;
+    readonly mediaType?: string;
+    readonly fallbackText?: string;
+}
+/** A linked agent session, with its owning call resolved when the facts name one. */
+export interface ChildObservation {
+    readonly sessionId: string;
+    readonly name: string;
+    readonly callId?: string;
+}
+export interface SessionObservation extends ObservationTiming {
+    readonly status: "new" | "open" | "ended";
+    readonly outcome?: SessionOutcome;
+    readonly error?: ErrorInfo;
+    readonly runtime?: RuntimeIdentity;
+    readonly parent?: {
+        readonly sessionId: string;
+        readonly callId: string;
+    };
+}
+export interface SessionUsage {
+    readonly total: Usage;
+    readonly byKind: {
+        readonly [kind: string]: Usage;
+    };
+}
+/** Uncommitted input text and progress, explicitly separate from a call's committed values. */
+export interface CallPreviewObservation {
+    readonly callId: string;
+    readonly input: string;
+    readonly output?: JsonValue;
+    readonly label?: string;
+}
+export interface ContentPreviewObservation {
+    readonly partId: string;
+    readonly runId?: string;
+    readonly kind: string;
+    readonly text: string;
+}
+export type Waiting = {
+    readonly on: "session";
+} | {
+    readonly on: "interaction";
+    readonly interactions: readonly Interaction[];
+} | {
+    readonly on: "work";
+    readonly calls: readonly CallObservation[];
+    readonly tasks: readonly TaskObservation[];
+};
+export type Activity = {
+    readonly kind: "idle" | "thinking" | "compacting";
+} | {
+    readonly kind: "calling";
+    readonly names: readonly string[];
+} | {
+    readonly kind: "waiting-on-interaction";
+    readonly interactions: readonly Interaction[];
+} | {
+    readonly kind: "waiting-on-tasks";
+    readonly tasks: readonly TaskObservation[];
+};

package/dist/src/protocol/session-projection/observations.js

@@ -0,0 +1 @@
+export{};