eve 0.83.2 → 0.84.0

package/dist/src/protocol/session-projection/public-view.d.ts

@@ -0,0 +1,74 @@
+import { type ReceivedEvent } from "./fold.js";
+import * as selectors from "./selectors.js";
+import { type Interaction } from "#protocol/session-projection/reader.js";
+import type { Capability } from "#protocol/session-events/families/call.js";
+import type { InteractionSubject } from "#protocol/session-events/families/interaction.js";
+import type { ErrorInfo } from "#protocol/session-events/envelope.js";
+import { type SessionView } from "./session-view.js";
+import type { CallFilter, CallObservation, TurnObservation, DeliveryObservation, TaskObservation, RunObservation, ContentObservation, ChildObservation, SessionObservation, SessionUsage, CallPreviewObservation, ContentPreviewObservation, Activity, Waiting } from "./observations.js";
+export type { SessionView } from "./session-view.js";
+export type * from "./observations.js";
+export type { ReceivedEvent } from "./fold.js";
+export type { CallState } from "./selectors.js";
+export type { RequestStatus } from "./request-status.js";
+/** A new empty snapshot, without a mutable table representation. */
+export declare function emptySessionView(): SessionView;
+/** Returns a new snapshot; incomplete commits remain private until their last event arrives. */
+export declare function foldEvents(view: SessionView, events: readonly ReceivedEvent[]): SessionView;
+/** Durable position of the next line, not an event count. */
+export declare function position(view: SessionView): number;
+export declare function session(view: SessionView): SessionObservation;
+export declare function turn(view: SessionView, turnId: string): TurnObservation | undefined;
+/** Retained turns, in the order they started. */
+export declare function turns(view: SessionView): readonly TurnObservation[];
+export declare function activeTurn(view: SessionView): TurnObservation | undefined;
+export declare function conversation(view: SessionView): readonly TurnObservation[];
+export declare function call(view: SessionView, callId: string): CallObservation | undefined;
+export declare function calls(view: SessionView, filter?: CallFilter): readonly CallObservation[];
+export declare function callState(view: SessionView, callId: string): selectors.CallState | undefined;
+/** A projected call already carries its display label; request facts may also be labelled. */
+export declare function callLabel(value: CallObservation | {
+    readonly capability: Capability;
+    readonly label?: string;
+    readonly status?: "requested" | "running" | "settled";
+}, preview?: {
+    readonly label?: string;
+}): string;
+export declare function callOutputSource(view: SessionView, callId: string): CallObservation | undefined;
+export declare function interaction(view: SessionView, interactionId: string): Interaction | undefined;
+export declare function interactions(view: SessionView): readonly Interaction[];
+export declare function openInteractions(view: SessionView, filter?: {
+    readonly kind?: string;
+    readonly about?: InteractionSubject;
+}): readonly Interaction[];
+export declare function delivery(view: SessionView, deliveryId: string): DeliveryObservation | undefined;
+export declare function deliveries(view: SessionView, filter?: {
+    readonly turnId?: string;
+}): readonly DeliveryObservation[];
+export declare function queue(view: SessionView): readonly DeliveryObservation[];
+export declare function task(view: SessionView, taskId: string): TaskObservation | undefined;
+export declare function tasks(view: SessionView, filter?: {
+    readonly status?: "working" | "idle" | "ended";
+}): readonly TaskObservation[];
+export declare function runs(view: SessionView, filter?: {
+    readonly turnId?: string;
+}): readonly RunObservation[];
+export declare function part(view: SessionView, partId: string): ContentObservation | undefined;
+export declare function parts(view: SessionView, filter?: {
+    readonly runId?: string;
+    readonly turnId?: string;
+    readonly kind?: string;
+}): readonly ContentObservation[];
+export declare function reply(view: SessionView, turnId: string): readonly ContentObservation[];
+export declare function children(view: SessionView): readonly ChildObservation[];
+export declare function usage(view: SessionView): SessionUsage;
+export declare function failure(view: SessionView, turnId?: string): ErrorInfo | undefined;
+export declare function idle(view: SessionView): boolean;
+export declare function waiting(view: SessionView, turnId: string): Waiting | undefined;
+export declare function activity(view: SessionView, filter?: {
+    readonly turnId?: string;
+}): Activity;
+export declare function callPreview(view: SessionView, callId: string): CallPreviewObservation | undefined;
+export declare function contentPreviews(view: SessionView, filter?: {
+    readonly runId?: string;
+}): readonly ContentPreviewObservation[];

package/dist/src/protocol/session-projection/public-view.js

@@ -0,0 +1 @@
+import{copyView,emptySessionView as emptySessionView$1,foldEvents as foldEvents$1}from"./fold.js";import{activeTurn as activeTurn$1,activity as activity$1,callLabel as callLabel$1,callOutputSource as callOutputSource$1,callRun,callState as callState$1,callTask,callTurn,conversation as conversation$1,failure as failure$1,idle as idle$1,openInteractions as openInteractions$1,queue as queue$1,reply as reply$1,runTurn,tasks as tasks$1,waiting as waiting$1}from"./selectors.js";import{sessionTables,snapshotOf,snapshotState}from"./session-view.js";import{interaction as interaction$1}from"#protocol/session-projection/reader.js";function frozen(e){if(typeof e==`object`&&e&&!Object.isFrozen(e)){for(let t of Object.values(e))frozen(t);Object.freeze(e)}return e}function emptySessionView(){return snapshotOf(emptySessionView$1())}function foldEvents(e,t){let n=snapshotState(e),r=copyView(n.tables),i={calls:{...n.previews.calls},parts:{...n.previews.parts}},a=new Map;for(let e of[...n.pending,...t])a.set(`${e.meta.position.line}:${e.meta.position.index}`,e);let o=[...a.values()].sort((e,t)=>e.meta.position.line-t.meta.position.line||e.meta.position.index-t.meta.position.index),s=foldEvents$1(r,o,{previews:i});return snapshotOf(r,i,s)}function position(e){return sessionTables(e).position}function session(e){let{status:t,outcome:n,error:r,runtime:i,parent:a,startedAt:o,endedAt:s}=sessionTables(e).session;return frozen({status:t,outcome:n,error:r,runtime:i,parent:a,startedAt:o,endedAt:s})}function turn(e,t){let n=sessionTables(e).turns[t];if(n===void 0)return;let{status:r,outcome:i,error:a,startedAt:o,endedAt:s}=n;return frozen({turnId:t,status:r,outcome:i,error:a,startedAt:o,endedAt:s})}function turns(e){return frozen(Object.keys(sessionTables(e).turns).flatMap(t=>turn(e,t)??[]))}function activeTurn(e){let t=activeTurn$1(sessionTables(e));return t===void 0?void 0:turn(e,t.turnId)}function conversation(e){return frozen(conversation$1(sessionTables(e)).flatMap(t=>turn(e,t.turnId)??[]))}function call(e,t){let n=sessionTables(e),r=n.calls[t],i=callState$1(n,t);if(r===void 0||i===void 0)return;let a=callOutputSource$1(n,t),o={callId:t,name:r.capability.name,kind:r.capability.kind,label:callLabel$1(r,snapshotState(e).previews.calls[t]),runId:callRun(n,r),turnId:callTurn(n,r),taskId:callTask(n,r),input:r.input,inputRef:r.inputRef,output:a?.output,outputRef:a?.outputRef,outcome:r.outcome,reason:r.reason,clearedBy:r.clearedBy,usage:r.usage,startedAt:r.startedAt,endedAt:r.endedAt},s=r.error??r.inputError;return frozen(i===`failed`?{...o,state:i,error:s??{code:`CALL_FAILED`,message:`The call failed.`}}:{...o,state:i,error:s})}function calls(e,t={}){return frozen(Object.keys(sessionTables(e).calls).flatMap(n=>{let r=call(e,n);return r!==void 0&&(t.kind===void 0||t.kind===r.kind)&&(t.name===void 0||t.name===r.name)&&(t.turnId===void 0||t.turnId===r.turnId)&&(t.runId===void 0||t.runId===r.runId)&&(t.taskId===void 0||t.taskId===r.taskId)?[r]:[]}))}function callState(e,t){return callState$1(sessionTables(e),t)}function callLabel(e,t){return`capability`in e?callLabel$1(e,t):e.label}function callOutputSource(e,t){let n=callOutputSource$1(sessionTables(e),t);return n===void 0?void 0:call(e,n.callId)}function interaction(e,t){return frozen(interaction$1(sessionTables(e),t))}function interactions(e){return frozen(Object.keys(sessionTables(e).interactions).flatMap(t=>interaction(e,t)??[]))}function openInteractions(e,t={}){return frozen(openInteractions$1(sessionTables(e),t).flatMap(t=>interaction(e,t.interactionId)??[]))}function delivery(e,t){let n=sessionTables(e).deliveries[t];if(n===void 0)return;let{status:r,turnId:i,outcome:a,reason:o,source:s,principal:c,parts:l,startedAt:u,endedAt:d}=n;return frozen({deliveryId:t,status:r,turnId:i,outcome:a,reason:o,source:s,principal:c,parts:l,startedAt:u,endedAt:d})}function deliveries(e,t={}){return frozen(Object.keys(sessionTables(e).deliveries).flatMap(n=>{let r=delivery(e,n);return r!==void 0&&(t.turnId===void 0||r.turnId===t.turnId)?[r]:[]}))}function queue(e){return frozen(queue$1(sessionTables(e)).flatMap(t=>delivery(e,t.deliveryId)??[]))}function task(e,t){let n=sessionTables(e).tasks[t];if(n===void 0)return;let{name:r,kind:i,status:a,outcome:o,reason:s,error:c,startedAt:l,endedAt:u}=n;return frozen({taskId:t,callId:n.startedBy.callId,name:r,kind:i,status:a,outcome:o,reason:s,error:c,startedAt:l,endedAt:u})}function tasks(e,t={}){return frozen(tasks$1(sessionTables(e),t).flatMap(t=>task(e,t.taskId)??[]))}function runs(e,t={}){let n=sessionTables(e);return frozen(Object.values(n.runs).flatMap(e=>{let r=runTurn(n,e.runId);if(t.turnId!==void 0&&t.turnId!==r)return[];let{runId:i,status:a,modelId:o,outcome:s,finishReason:c,error:l,usage:u,startedAt:d,endedAt:f}=e;return[{runId:i,turnId:r,status:a,modelId:o,outcome:s,finishReason:c,error:l,usage:u,startedAt:d,endedAt:f}]}))}function part(e,t){let n=sessionTables(e).parts[t];if(n===void 0)return;let{runId:r,kind:i,phase:a,value:o,valueRef:s,interrupted:c,mediaType:l,fallbackText:u,startedAt:d}=n;return frozen({partId:t,runId:r,kind:i,phase:a,value:o,valueRef:s,interrupted:c,mediaType:l,fallbackText:u,startedAt:d})}function parts(e,t={}){let n=sessionTables(e);return frozen(Object.values(n.parts).flatMap(r=>t.runId!==void 0&&r.runId!==t.runId||t.turnId!==void 0&&runTurn(n,r.runId)!==t.turnId||t.kind!==void 0&&r.kind!==t.kind?[]:part(e,r.partId)??[]))}function reply(e,t){return frozen(reply$1(sessionTables(e),t).flatMap(t=>part(e,t.partId)??[]))}function children(e){let t=sessionTables(e);return frozen(Object.values(t.children).map(e=>({sessionId:e.sessionId,name:e.name,callId:`callId`in e.owner?e.owner.callId:t.tasks[e.owner.taskId]?.startedBy.callId})))}function usage(e){let{total:t,byKind:n}=sessionTables(e).usage;return frozen({total:t,byKind:n})}function failure(e,t){return frozen(failure$1(sessionTables(e),t))}function idle(e){return idle$1(sessionTables(e))}function waiting(e,t){let n=waiting$1(sessionTables(e),t);if(n!==void 0)return n.on===`session`?frozen({on:`session`}):n.on===`interaction`?frozen({on:`interaction`,interactions:n.interactions.flatMap(t=>interaction(e,t.interactionId)??[])}):frozen({on:`work`,calls:n.calls.flatMap(t=>call(e,t.callId)??[]),tasks:n.tasks.flatMap(t=>task(e,t.taskId)??[])})}function activity(e,t={}){let n=activity$1(sessionTables(e),t);return n.kind===`waiting-on-interaction`?frozen({...n,interactions:n.interactions.flatMap(t=>interaction(e,t.interactionId)??[])}):n.kind===`waiting-on-tasks`?frozen({...n,tasks:n.tasks.flatMap(t=>task(e,t.taskId)??[])}):frozen(n)}function callPreview(e,t){let n=snapshotState(e).previews.calls[t];if(n===void 0)return;let{input:r,output:i,label:a}=n;return frozen({callId:t,input:r,output:i,label:a})}function contentPreviews(e,t={}){return frozen(Object.values(snapshotState(e).previews.parts).filter(e=>t.runId===void 0||e.runId===t.runId).map(({partId:e,runId:t,kind:n,text:r})=>({partId:e,runId:t,kind:n,text:r})))}export{activeTurn,activity,call,callLabel,callOutputSource,callPreview,callState,calls,children,contentPreviews,conversation,deliveries,delivery,emptySessionView,failure,foldEvents,idle,interaction,interactions,openInteractions,part,parts,position,queue,reply,runs,session,task,tasks,turn,turns,usage,waiting};

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

@@ -0,0 +1,62 @@
+import type { InteractionOutcome, InteractionRequest, SignInChallenge } from "#protocol/session-events/families/interaction.js";
+import type { Answer } from "#protocol/session-events/families/response.js";
+import type { JsonValue } from "#protocol/session-events/envelope.js";
+import type { InteractionRow, SessionView } from "#protocol/session-projection/tables.js";
+/** Where a model run's output goes: its turn, and its step, the run's place among its turn's. */
+export interface RunPlace {
+    readonly turnId: string;
+    readonly stepIndex: number;
+}
+export declare function runPlace(view: SessionView, runId: string | undefined): RunPlace | undefined;
+/** A turn's latest step as of a position: the place of its last run introduced by then. */
+export declare function turnStepAt(view: SessionView, turnId: string, position?: number): number;
+/** Where a call belongs: its run's place, or its turn's latest step when no run of a turn made it. */
+export declare function callPlace(view: SessionView, callId: string): RunPlace | undefined;
+/** Why a request nobody answered closed when a message steered its turn instead. */
+export declare const SUPERSEDED_BY_MESSAGE = "superseded-by-message";
+/** The call an interaction asks about. */
+export interface AskedCall {
+    readonly callId: string;
+    readonly name: string;
+    readonly input?: JsonValue;
+}
+/**
+ * The call an interaction asks about, such as the tool an approval would run: a relayed
+ * request's asker's call, which lives in the child's session, or else the subject's call here.
+ */
+export declare function askedCall(view: SessionView, row: InteractionRow): AskedCall | undefined;
+/** Where an interaction opened: the turn it holds, its step then, and the task whose run asks. */
+type InteractionPlace = Pick<Interaction, "turnId" | "stepIndex" | "taskId">;
+export declare function interactionPlace(view: SessionView, row: InteractionRow): InteractionPlace;
+/** An interaction as a conversation reader shows it: what it asks, where, and how it stands. */
+export interface Interaction {
+    readonly interactionId: string;
+    readonly turnId: string;
+    readonly stepIndex: number;
+    readonly taskId?: string;
+    readonly request: Omit<InteractionRequest, "signIn"> & {
+        readonly signIn?: Omit<SignInChallenge, "callbackUrl">;
+    };
+    readonly call?: AskedCall;
+    readonly status: "open" | "settled";
+    readonly outcome?: InteractionOutcome;
+    readonly reason?: string;
+    /** The deciding answer once settled; while open, the latest unsettled submitted answer. */
+    readonly answer?: Answer;
+}
+export declare function interaction(view: SessionView, interactionId: string): Interaction | undefined;
+/** The answer that decided a settled interaction, as it was given. */
+export declare function decidingAnswer(row: InteractionRow): Answer | undefined;
+/**
+ * The approvals, questions, and budget prompts the session still waits on an answer to, oldest
+ * first: the server's one source for whether a request is open. A sign-in completes by its
+ * callback, not an answer (`openSignIns`).
+ */
+export declare function openRequests(view: SessionView | undefined): readonly InteractionRow[];
+/** Sign-ins the session still waits on, in the order they opened. */
+export declare function openSignIns(view: SessionView | undefined): readonly InteractionRow[];
+/** How a sign-in's end reads to a person: connected, or why it didn't. */
+export declare function signInEnding(outcome: InteractionOutcome): "connected" | "declined" | "failed" | "timed out" | "cancelled";
+/** The prompt a text-only channel displays: budget first, then the oldest unanswered request. */
+export declare function promptQueueHead(view: SessionView, answered?: (interactionId: string) => boolean): InteractionRow | undefined;
+export {};

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

@@ -0,0 +1 @@
+import{answeredInteractionIds,callRun,callTurn,interactionOwner,openInteractions}from"#protocol/session-projection/selectors.js";function runPlace(e,t){let n=t===void 0?void 0:e.runs[t];if(n!==void 0&&n.step!==void 0&&`turnId`in n.owner)return{stepIndex:n.step,turnId:n.owner.turnId}}function turnStepAt(e,t,n=1/0){let r=0;for(let i of Object.values(e.runs))i.step===void 0||i.introducedAt>n||`turnId`in i.owner&&i.owner.turnId===t&&(r=Math.max(r,i.step));return r}function callPlace(e,t){let n=e.calls[t];if(n===void 0)return;let r=runPlace(e,callRun(e,n));if(r!==void 0)return r;let i=callTurn(e,n)??e.session.latestTurnId;return i===void 0?void 0:{stepIndex:turnStepAt(e,i,n.introducedAt),turnId:i}}const SUPERSEDED_BY_MESSAGE=`superseded-by-message`;function askedCall(e,t){if(t.origin!==void 0)return t.origin.call;if(!(`callId`in t.subject))return;let n=e.calls[t.subject.callId];if(n!==void 0)return n.input===void 0?{callId:n.callId,name:n.capability.name}:{callId:n.callId,input:n.input,name:n.capability.name}}function interactionPlace(e,t){let n=interactionOwner(e,t),r=n.turnId??e.session.latestTurnId??`turn_0`,i={stepIndex:turnStepAt(e,r,t.introducedAt),turnId:r},a=n.taskId??(`taskId`in t.subject?t.subject.taskId:void 0);return a!==void 0&&(i.taskId=a),i}function interaction(e,t){let n=e.interactions[t];if(n===void 0)return;let r=n.request;if(n.request.signIn!==void 0){let{callbackUrl:e,...t}=n.request.signIn;r={...n.request,signIn:t}}let i={...interactionPlace(e,n),interactionId:t,request:r,status:n.status},a=askedCall(e,n);a!==void 0&&(i.call=a),n.outcome!==void 0&&(i.outcome=n.outcome),n.reason!==void 0&&(i.reason=n.reason);let o=decidingAnswer(n);if(n.status===`open`)for(let n of Object.values(e.responses))n.interactionId===t&&n.status!==`settled`&&n.value!==void 0&&(o={...n.value,interactionId:t});return o!==void 0&&(i.answer=o),i}function decidingAnswer(e){let t=e.response;if(t===void 0)return;let n={interactionId:e.interactionId};return typeof t.optionId==`string`&&(n.optionId=t.optionId),typeof t.text==`string`&&(n.text=t.text),n.optionId===void 0&&n.text===void 0?void 0:n}function openRequests(e){return e===void 0?[]:openInteractions(e).filter(e=>e.request.kind!==`sign-in`)}function openSignIns(e){return e===void 0?[]:openInteractions(e,{kind:`sign-in`})}function signInEnding(e){switch(e){case`accepted`:return`connected`;case`declined`:case`invalid`:return`declined`;case`failed`:return`failed`;case`expired`:return`timed out`;default:return`cancelled`}}function promptQueueHead(e,t=()=>!1){let n=answeredInteractionIds(e),r=openRequests(e).filter(e=>!t(e.interactionId)&&!n.has(e.interactionId));return r.find(e=>e.request.kind===`budget`)??r[0]}export{SUPERSEDED_BY_MESSAGE,askedCall,callPlace,decidingAnswer,interaction,interactionPlace,openRequests,openSignIns,promptQueueHead,runPlace,signInEnding,turnStepAt};

package/dist/src/protocol/session-projection/request-status.d.ts

@@ -0,0 +1,7 @@
+import type { DeliveryOutcome } from "#protocol/session-events/families/delivery.js";
+import type { TurnOutcome } from "#protocol/session-events/families/turn.js";
+import type { SessionOutcome } from "#protocol/session-events/families/session.js";
+/** A settled delivery's result, separate from whether its session can accept more input. */
+export type RequestStatus = "awaiting-input" | "completed" | "failed" | "cancelled";
+/** Shared by complete views and response readers that joined a turn after its introduction. */
+export declare function deliveryStatus(outcome: DeliveryOutcome | undefined, turn: TurnOutcome | undefined, session?: SessionOutcome): RequestStatus | "working";

package/dist/src/protocol/session-projection/request-status.js

@@ -0,0 +1 @@
+function deliveryStatus(e,t,n){switch(e){case void 0:return n===`failed`?`failed`:`working`;case`awaiting-input`:return`awaiting-input`;case`failed`:case`refused`:return`failed`;case`ignored`:case`applied`:return`completed`;case`handled`:return t===`cancelled`?`cancelled`:t===`failed`?`failed`:`completed`;default:return`failed`}}export{deliveryStatus};

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

@@ -0,0 +1,169 @@
+import type { ErrorInfo } from "#protocol/session-events/envelope.js";
+import type { InteractionSubject } from "#protocol/session-events/families/interaction.js";
+import type { CallRow, ChangeRow, DeliveryRow, InteractionRow, PartRow, ResponseRow, RunRow, SessionView, TaskRow, TurnRow } from "./tables.js";
+/** The turn that is running or paused, if any. */
+export declare function activeTurn(view: SessionView): TurnRow | undefined;
+/**
+ * The conversation as the model last saw it: the selected turn and the turns it follows back,
+ * oldest first. The selected turn is the newest, unless a later context change chose another;
+ * a clear selects none. A turn not retained here ends the walk.
+ */
+export declare function conversation(view: SessionView): readonly TurnRow[];
+/** The content parts that answer a turn, in order. */
+export declare function reply(view: SessionView, turnId: string): readonly PartRow[];
+/** A turn's reply as text: its text parts, one per line. */
+export declare function replyText(view: SessionView, turnId: string): string | undefined;
+/**
+ * The interactions each commit opened, oldest first: one batch is asked, and answered, together.
+ * Sign-ins are connection work, not questions, and stay out unless asked for.
+ */
+export declare function interactionBatches(view: SessionView, options?: {
+    readonly signIns?: boolean;
+}): readonly (readonly InteractionRow[])[];
+/** Why a turn failed, or why the session did. */
+export declare function failure(view: SessionView, turnId?: string): ErrorInfo | undefined;
+/** The call carrying a shared result. A reply stores its value once, not once per recipient. */
+export declare function callOutputSource(view: SessionView, callId: string): CallRow | undefined;
+/** True while any call the task serves is unsettled. Idle tasks don't hold the session open. */
+export declare function isWorking(view: SessionView, taskId: string): boolean;
+/** Tasks, optionally only the working or the idle ones. */
+export declare function tasks(view: SessionView, filter?: {
+    readonly status?: "working" | "idle" | "ended";
+}): readonly TaskRow[];
+/** Open interactions, oldest first; `about` includes interactions holding the entity's work. */
+export declare function openInteractions(view: SessionView, filter?: {
+    readonly kind?: string;
+    readonly about?: InteractionSubject;
+}): readonly InteractionRow[];
+/**
+ * Open interactions that hold an admitted answer: answered for now, waiting for the rest of
+ * their batch to be decided. A typed reply moves on to the next request past them.
+ */
+export declare function answeredInteractionIds(view: SessionView): ReadonlySet<string>;
+/** Deliveries admitted but not yet consumed or settled, in arrival order. */
+export declare function queue(view: SessionView): readonly DeliveryRow[];
+/**
+ * True when nothing is happening and nothing will until another delivery arrives: no turn the
+ * session works on or that waits on work, no working task, no open context change, and no queued
+ * delivery. A turn waiting only on interactions is idle. An ended session is idle.
+ */
+export declare function idle(view: SessionView): boolean;
+/** What an open turn waits on, when the session can do nothing more for it by itself. */
+export type Waiting = {
+    readonly on: "session";
+} | {
+    readonly on: "interaction";
+    readonly interactions: readonly InteractionRow[];
+} | {
+    readonly on: "work";
+    readonly calls: readonly CallRow[];
+    readonly tasks: readonly TaskRow[];
+};
+/**
+ * What an open turn waits on, read from the tables; `undefined` only for absent or settled turns.
+ * `session` means the session can make progress by itself.
+ *
+ * The session works on a turn while it has a model run open, a context change running, an
+ * answer it hasn't weighed, or a delivery the turn consumed after it last requested a run or
+ * asked someone. Otherwise the
+ * turn waits on an interaction while any unanswered interaction under it is open, and on work while
+ * calls it made run, such as a workflow tool's run or a task it waits for. With neither, the
+ * session has something to do: start or ask about requested calls, call the model, or end the
+ * turn. So `session` means the session can make progress on this turn by itself.
+ *
+ * Rules of the stream make this exact at every line: anything that needs an answer is an
+ * interaction; the line that makes a model call necessary requests the run; and every call
+ * another run serves names its task when it starts.
+ */
+export declare function waiting(view: SessionView, turnId: string): Waiting | undefined;
+/** The approval this session asked about a call itself, not one relayed from elsewhere. */
+export declare function ownApproval(view: SessionView, callId: string): InteractionRow | undefined;
+/**
+ * Where a call stands, for a display: `requested` until the session starts it, `approval` while
+ * its own approval is open, `running`, `blocked` while its work waits on an interaction, then how it
+ * ended. A call interrupted or abandoned reads as `cancelled`; an outcome a newer writer adds
+ * reads as `failed`.
+ */
+export type CallState = "requested" | "approval" | "running" | "blocked" | "completed" | "failed" | "rejected" | "cancelled";
+/** Where a call stands; `undefined` for a call the tables don't hold. */
+export declare function callState(view: SessionView, callId: string): CallState | undefined;
+/**
+ * A call's label: the one its tool gave its result or, while it runs, its latest progress; else
+ * its capability's label, else its name as a title (`linear__list_issues` → `List issues`). A
+ * `call.requested`'s data reads as its call's row did then.
+ */
+export declare function callLabel(row: Pick<CallRow, "capability"> & Partial<Pick<CallRow, "status" | "label">>, preview?: {
+    readonly label?: string;
+}): string;
+/** What the session is doing right now, for status lines. */
+export type Activity = {
+    readonly kind: "idle";
+} | {
+    readonly kind: "thinking";
+} | {
+    readonly kind: "calling";
+    readonly names: readonly string[];
+} | {
+    readonly kind: "waiting-on-interaction";
+    readonly interactions: readonly InteractionRow[];
+} | {
+    readonly kind: "waiting-on-tasks";
+    readonly tasks: readonly TaskRow[];
+} | {
+    readonly kind: "compacting";
+};
+/** What the session, or one turn, is doing right now. */
+export declare function activity(view: SessionView, filter?: {
+    readonly turnId?: string;
+}): Activity;
+/** The run that made a call, directly or through the calls it was made inside. */
+export declare function callRun(view: SessionView, entry: CallRow): string | undefined;
+/** The turn a call belongs to: the turn of the run that made it. */
+export declare function callTurn(view: SessionView, entry: CallRow): string | undefined;
+/** The task serving a call, directly or through a call it was made inside. */
+export declare function callTask(view: SessionView, entry: CallRow): string | undefined;
+/** The turn a run belongs to: the turn that requested it, or the turn its context change is in. */
+export declare function runTurn(view: SessionView, runId: string): string | undefined;
+/** What an owner leaves open: the entities that still need a terminal fact. */
+export interface OpenWork {
+    readonly calls: readonly CallRow[];
+    readonly runs: readonly RunRow[];
+    readonly changes: readonly ChangeRow[];
+    readonly deliveries: readonly DeliveryRow[];
+    readonly tasks: readonly TaskRow[];
+    readonly interactions: readonly InteractionRow[];
+    readonly responses: readonly ResponseRow[];
+}
+/** Where an interaction belongs: what its subject belongs to, through calls and responses. */
+export interface InteractionOwner {
+    readonly turnId?: string;
+    readonly taskId?: string;
+    readonly runId?: string;
+    readonly changeId?: string;
+}
+/** The owner an interaction closes with: its turn, its task, or the run that made its call. */
+export declare function interactionOwner(view: SessionView, entry: InteractionRow): InteractionOwner;
+/**
+ * The work still open under an owner, by ownership:
+ *
+ * - a run: the run and the calls it made, directly or inside other calls;
+ * - a context change: the change, its runs, and their calls;
+ * - a turn: its runs and their calls, the context changes inside it, and the deliveries it
+ *   consumed. A task's calls belong to the task, so they survive closure of their run or turn;
+ * - the session: everything.
+ *
+ * The turn and session rows themselves aren't included: their own terminal facts close them.
+ */
+export declare function openWork(view: SessionView, owner: {
+    readonly runId: string;
+} | {
+    readonly changeId: string;
+} | {
+    readonly turnId: string;
+} | {
+    readonly taskId: string;
+} | {
+    readonly session: true;
+}): OpenWork;
+/** The turn an interaction is about, directly or through its call. */
+export declare function subjectTurn(view: SessionView, entry: InteractionRow): string | undefined;

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

@@ -0,0 +1,2 @@
+import{displayTitle}from"#protocol/session-projection/display-name.js";import{isOpen,openUnder,ownerOf,refOf,rowOf}from"#protocol/session-projection/tree.js";function activeTurn(e){if(e.session.status===`ended`)return;let t=e.session.latestTurnId,n=t===void 0?void 0:e.turns[t];return n!==void 0&&n.status!==`settled`?n:void 0}function conversation(e){let t=e.selection,n=t===void 0?e.session.latestTurnId:t?.turnId,r=[],i=new Set,a=n;for(;a!=null&&!i.has(a);){i.add(a);let t=e.turns[a];if(t===void 0)break;r.push(t),a=t.follows}return r.reverse()}function reply(e,t){return(e.turns[t]?.reply??[]).flatMap(t=>{let n=e.parts[t];return n===void 0?[]:[n]})}function replyText(e,t){let n=reply(e,t).flatMap(e=>e.kind===`text`&&typeof e.value==`string`?[e.value]:[]);return n.length===0?void 0:n.join(`
+`)}function interactionBatches(e,t={}){let n=new Map,r=Object.values(e.interactions).sort((e,t)=>e.introducedAt-t.introducedAt);for(let e of r){if(e.request.kind===`sign-in`&&t.signIns!==!0)continue;let r=n.get(e.introducedAt);r===void 0?n.set(e.introducedAt,[e]):r.push(e)}return[...n.values()]}function failure(e,t){let n=t===void 0?void 0:e.turns[t];if(n?.outcome===`failed`)return n.error??{code:`TURN_FAILED`,message:`The turn failed.`};if(e.session.outcome===`failed`)return e.session.error??{code:`SESSION_FAILED`,message:`The session failed.`}}function callOutputSource(e,t){let n=new Set,r=e.calls[t];for(;r!==void 0&&!n.has(r.callId);){if(n.add(r.callId),r.outcome!==`completed`||r.outputOf===void 0)return r;r=e.calls[r.outputOf.callId]}}function isWorking(e,t){return e.session.status===`ended`||e.tasks[t]?.status!==`running`?!1:Object.values(e.calls).some(n=>n.status!==`settled`&&callTask(e,n)===t)}function tasks(e,t={}){return Object.values(e.tasks).filter(n=>{switch(t.status){case void 0:return!0;case`ended`:return n.status===`ended`;case`working`:return isWorking(e,n.taskId);case`idle`:return n.status===`running`&&!isWorking(e,n.taskId)}})}function openInteractions(e,t={}){return e.session.status===`ended`?[]:Object.values(e.interactions).filter(n=>{if(n.status!==`open`||t.kind!==void 0&&n.request.kind!==t.kind)return!1;let r=t.about;if(r===void 0)return!0;if(`callId`in r){let t=e.calls[r.callId];return`callId`in n.subject&&n.subject.callId===r.callId||n.origin?.call?.callId===r.callId||t?.taskId!==void 0&&interactionOwner(e,n).taskId===t.taskId}return`taskId`in r?interactionOwner(e,n).taskId===r.taskId:`turnId`in r?interactionOwner(e,n).turnId===r.turnId:sameSubject(n.subject,r)}).sort((e,t)=>e.introducedAt-t.introducedAt)}function answeredInteractionIds(e){return new Set(Object.values(e.responses).filter(e=>e.status===`admitted`).map(e=>e.interactionId))}function queue(e){return e.session.status===`ended`?[]:Object.values(e.deliveries).filter(e=>e.status===`admitted`).sort((e,t)=>e.introducedAt-t.introducedAt)}function idle(e){if(e.session.status===`ended`)return!0;let t=activeTurn(e);return t!==void 0&&waiting(e,t.turnId)?.on!==`interaction`||Object.values(e.changes).some(e=>e.status===`running`)||queue(e).length>0?!1:!Object.keys(e.tasks).some(t=>isWorking(e,t))}function waiting(e,t){if(e.session.status===`ended`)return;let n=e.turns[t];if(n===void 0||n.status===`settled`)return;let r=openWork(e,{turnId:t});if(r.runs.length>0||r.changes.length>0)return{on:`session`};let i=new Set(r.interactions.flatMap(e=>`responseId`in e.subject?[e.subject.responseId]:[]));if(r.responses.some(e=>e.status===`submitted`&&!i.has(e.responseId)))return{on:`session`};let a=Math.max(-1,...Object.values(e.runs).filter(n=>runTurn(e,n.runId)===t).map(e=>e.introducedAt),...Object.values(e.interactions).filter(n=>interactionOwner(e,n).turnId===t||subjectTurn(e,n)===t).map(e=>e.introducedAt),...Object.values(e.responses).filter(n=>n.status!==`submitted`&&e.deliveries[n.deliveryId]?.turnId===t).map(e=>e.introducedAt));if(Object.values(e.deliveries).some(e=>e.status===`consumed`&&e.turnId===t&&(e.consumedAt??-1)>a))return{on:`session`};let o=Object.values(e.interactions),about=e=>new Set(o.flatMap(t=>e(t)?[...`callId`in t.subject?[t.subject.callId]:[],...t.origin?.call===void 0?[]:[t.origin.call.callId]]:[])),s=about(e=>e.status===`open`),c=about(e=>e.status===`settled`&&e.outcome===`accepted`),l=Object.values(e.calls).filter(n=>n.status!==`settled`&&callTurn(e,n)===t),u=l.filter(e=>e.status===`running`),d=answeredInteractionIds(e);if(!o.some(e=>e.status===`open`&&e.request.kind===`sign-in`&&`turnId`in e.subject&&e.subject.turnId===t&&!d.has(e.interactionId))&&u.some(e=>e.taskId===void 0&&e.capability.name!==`eve__task_wait`&&!s.has(e.callId)))return{on:`session`};let f=l.filter(e=>e.status===`requested`&&!s.has(e.callId));if(f.some(e=>c.has(e.callId))||f.some(e=>e.capability.kind===`control`&&e.capability.name===`eve__task_cancel`)||f.length>0&&u.length===0)return{on:`session`};let p=openInteractions(e).filter(n=>!d.has(n.interactionId)&&!(`callId`in n.subject&&e.calls[n.subject.callId]?.status===`settled`)&&(interactionOwner(e,n).turnId===t||subjectTurn(e,n)===t));if(p.length>0)return{interactions:p,on:`interaction`};if(u.length>0){let t=new Set(u.flatMap(e=>e.taskId??[]));if(u.some(e=>e.capability.name===`eve__task_wait`))for(let n of tasks(e,{status:`working`}))t.add(n.taskId);return{on:`work`,calls:u,tasks:[...t].flatMap(t=>e.tasks[t]??[])}}return{on:`session`}}function ownApproval(e,t){let n;for(let r of Object.values(e.interactions))r.request.kind===`approval`&&r.origin===void 0&&`callId`in r.subject&&r.subject.callId===t&&(n=r);return n}function callState(e,t){let n=e.calls[t];if(n===void 0)return;if(n.status===`settled`)switch(n.outcome){case`completed`:case`failed`:case`rejected`:return n.outcome;case`interrupted`:case`abandoned`:return`cancelled`;default:return`failed`}let r=answeredInteractionIds(e),i=openInteractions(e,{about:{callId:t}}).filter(e=>!r.has(e.interactionId));if(i.length>0){let n=ownApproval(e,t);return i.some(e=>e===n)?`approval`:`blocked`}return n.status===`requested`?`requested`:`running`}function callLabel(e,t){return e.label??(e.status===`settled`?void 0:t?.label)??e.capability.label??displayTitle(e.capability.name)}function activity(e,t={}){let n=t.turnId===void 0?activeTurn(e):e.turns[t.turnId];if(Object.values(e.changes).some(e=>e.status===`running`&&e.kind===`compaction`&&(n===void 0||e.turnId===void 0||e.turnId===n.turnId)))return{kind:`compacting`};if(n===void 0||n.status===`settled`)return{kind:`idle`};let r=waiting(e,n.turnId);if(r?.on===`interaction`)return{interactions:r.interactions,kind:`waiting-on-interaction`};if(r?.on===`work`){let e=r.tasks;return e.length>0?{kind:`waiting-on-tasks`,tasks:e}:{kind:`calling`,names:r.calls.map(e=>callLabel(e))}}let i=Object.values(e.calls).filter(t=>t.status===`running`&&t.capability.kind!==`control`&&callTask(e,t)===void 0&&callTurn(e,t)===n.turnId);return i.length>0?{kind:`calling`,names:i.map(e=>callLabel(e))}:{kind:`thinking`}}function callRun(e,t){let n=new Set,r=t;for(;r!==void 0&&!n.has(r.callId);){if(n.add(r.callId),`runId`in r.owner)return r.owner.runId;r=e.calls[r.owner.callId]}}function callTurn(e,t){let n=callRun(e,t);return n===void 0||e.runs[n]===void 0?void 0:runTurn(e,n)}function callTask(e,t){return ownerOf(e,{family:`call`,id:t.callId},`task`)}function runTurn(e,t){return ownerOf(e,{family:`run`,id:t},`turn`)}function interactionOwner(e,t){let n={family:`interaction`,id:t.interactionId},r={};for(let t of[`turn`,`task`,`run`,`change`]){let i=ownerOf(e,n,t);i!==void 0&&(r[`${t}Id`]=i)}return r}function openWork(e,t){if(e.session.status===`ended`)return{calls:[],changes:[],deliveries:[],interactions:[],responses:[],runs:[],tasks:[]};let n=`session`in t?`session`:refOf(t),r=openUnder(e,n);n!==`session`&&n.family!==`turn`&&isOpen(e,n)&&r.push(n);let rows=t=>r.flatMap(n=>{let r=n.family===t?rowOf(e,t,n.id):void 0;return r===void 0?[]:[r]}),i=new Set(n!==`session`&&n.family===`turn`?Object.values(e.responses).flatMap(t=>ownerOf(e,{family:`response`,id:t.responseId},`turn`)===n.id?[t.deliveryId]:[]):[]),a=[...rows(`delivery`),...Object.values(e.deliveries).filter(e=>e.status===`admitted`&&i.has(e.deliveryId))];return{calls:rows(`call`),changes:rows(`change`),deliveries:a,interactions:rows(`interaction`),responses:rows(`response`),runs:rows(`run`),tasks:rows(`task`)}}function subjectTurn(e,t){let{subject:n}=t;if(`turnId`in n)return n.turnId;if(`callId`in n){let t=e.calls[n.callId];return t===void 0?void 0:callTurn(e,t)}}function sameSubject(e,t){let[n,r]=Object.entries(e)[0]??[],[i,a]=Object.entries(t)[0]??[];return n===i&&r===a}export{activeTurn,activity,answeredInteractionIds,callLabel,callOutputSource,callRun,callState,callTask,callTurn,conversation,failure,idle,interactionBatches,interactionOwner,isWorking,openInteractions,openWork,ownApproval,queue,reply,replyText,runTurn,subjectTurn,tasks,waiting};

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

@@ -0,0 +1,18 @@
+import type { SessionView as Tables, SessionPreviews } from "./tables.js";
+import type { ReceivedEvent } from "./fold.js";
+declare const sessionViewBrand: unique symbol;
+/** An immutable observation snapshot. Persist events and cursors, not its backing representation. */
+export interface SessionView {
+    readonly [sessionViewBrand]: true;
+}
+interface Snapshot {
+    readonly tables: Tables;
+    readonly previews: SessionPreviews;
+    readonly pending: readonly ReceivedEvent[];
+}
+/** Internal publication boundary; rows are replaced by the fold and cloned at most once. */
+export declare function snapshotOf(view: Tables, previews?: SessionPreviews, pending?: readonly ReceivedEvent[]): SessionView;
+export declare function snapshotState(view: SessionView): Snapshot;
+/** Private access for execution and built-in renderers, never exported by a public entry. */
+export declare function sessionTables(view: SessionView): Tables;
+export {};

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

@@ -0,0 +1 @@
+import{emptyPreviews}from"./fold.js";const KEY=Symbol.for(`eve.session-view-registry.v1`),snapshots=globalThis[KEY]??=new WeakMap,immutableRows=new WeakMap;function immutable(e){if(typeof e!=`object`||!e)return e;let t=immutableRows.get(e);if(t!==void 0)return t;let n=structuredClone(e),r=[n],i=new Set;for(;r.length>0;){let e=r.pop();if(!i.has(e)){i.add(e);for(let t of Object.values(e))typeof t==`object`&&t&&r.push(t);Object.freeze(e)}}return immutableRows.set(e,n),immutableRows.set(n,n),n}function table(e){return Object.freeze(Object.fromEntries(Object.entries(e).map(([e,t])=>[e,immutable(t)])))}function snapshotOf(e,t=emptyPreviews(),n=[]){let r=Object.freeze({});return snapshots.set(r,{tables:Object.freeze({position:e.position,session:immutable(e.session),calls:table(e.calls),changes:table(e.changes),children:table(e.children),deliveries:table(e.deliveries),interactions:table(e.interactions),parts:table(e.parts),responses:table(e.responses),runs:table(e.runs),tasks:table(e.tasks),turns:table(e.turns),usage:immutable(e.usage),selection:immutable(e.selection)}),previews:Object.freeze({calls:table(t.calls),parts:table(t.parts)}),pending:immutable(n)}),r}function snapshotState(e){let t=snapshots.get(e);if(t===void 0)throw TypeError(`Invalid SessionView. Use emptySessionView() or a snapshot supplied by eve.`);return t}function sessionTables(e){return snapshotState(e).tables}export{sessionTables,snapshotOf,snapshotState};

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

@@ -0,0 +1,237 @@
+import type { CallOutcome, Capability, CapabilityKind, CallOwner, ClearedBy } from "#protocol/session-events/families/call.js";
+import type { ChildOpenedData } from "#protocol/session-events/families/child.js";
+import type { ContentKind, ContentPhase } from "#protocol/session-events/families/content.js";
+import type { ContextKind, ContextOutcome } from "#protocol/session-events/families/context.js";
+import type { DeliveryOutcome, DeliverySource } from "#protocol/session-events/families/delivery.js";
+import type { InteractionOpenedData, InteractionOutcome } from "#protocol/session-events/families/interaction.js";
+import type { ModelOutcome, ModelOwner } from "#protocol/session-events/families/model.js";
+import type { ResponseOutcome, ResponseValue } from "#protocol/session-events/families/response.js";
+import type { RuntimeIdentity, SessionOutcome } from "#protocol/session-events/families/session.js";
+import type { TaskOutcome } from "#protocol/session-events/families/task.js";
+import type { TurnOutcome } from "#protocol/session-events/families/turn.js";
+import type { Cause, ErrorInfo, JsonValue, Principal, Usage, UserPart, ValueReference } from "#protocol/session-events/envelope.js";
+/** Where and when a row's entity was introduced. */
+export interface Introduced {
+    /** The position of the line that introduced it. */
+    readonly introducedAt: number;
+    /** The time of that line. */
+    readonly startedAt: string;
+}
+/** When a row's entity ended, once it has. */
+export interface Ended {
+    /** The position of the line that ended it, comparable with `introducedAt`. */
+    readonly closedAt?: number;
+    /** The time of that line. */
+    readonly endedAt?: string;
+}
+export interface SessionRow extends Ended {
+    readonly status: "new" | "open" | "ended";
+    readonly startedAt?: string;
+    readonly parent?: {
+        readonly sessionId: string;
+        readonly callId: string;
+    };
+    readonly runtime?: RuntimeIdentity;
+    readonly outcome?: SessionOutcome;
+    readonly cause?: Cause;
+    readonly error?: ErrorInfo;
+    /** Turns started so far; the next turn is `turn_${turnCount}`. */
+    readonly turnCount: number;
+    /** The newest turn, which outlives retention. */
+    readonly latestTurnId?: string;
+}
+export interface DeliveryRow extends Introduced, Ended {
+    readonly deliveryId: string;
+    readonly principal?: Principal;
+    readonly source?: DeliverySource;
+    readonly status: "admitted" | "consumed" | "settled";
+    /** The turn that consumed it, or the turn its settlement points at. */
+    readonly turnId?: string;
+    /** The position of the line that consumed it. */
+    readonly consumedAt?: number;
+    readonly parts?: readonly UserPart[];
+    readonly outcome?: DeliveryOutcome;
+    readonly reason?: string;
+}
+export interface TurnRow extends Introduced, Ended {
+    readonly turnId: string;
+    readonly cause: Cause;
+    readonly follows: string | null;
+    /** Whether it waits, and on what, is derived: see `waiting` in the selectors. */
+    readonly status: "running" | "settled";
+    /** Model runs the turn requested so far: its steps. */
+    readonly runs?: number;
+    readonly reply?: readonly string[];
+    readonly outcome?: TurnOutcome;
+    readonly error?: ErrorInfo;
+    /** What ended it, such as the delivery or hook that cancelled it. */
+    readonly endedBy?: Cause;
+}
+export interface RunRow extends Introduced, Ended {
+    readonly runId: string;
+    readonly owner: ModelOwner;
+    readonly status: "requested" | "running" | "settled";
+    /** A turn's run's step: 0 for the turn's first run. A context change's run has none. */
+    readonly step?: number;
+    readonly modelId?: string;
+    /** The current attempt, from the latest `model.started`. */
+    readonly attempt?: number;
+    readonly outcome?: ModelOutcome;
+    readonly finishReason?: string;
+    readonly generationId?: string;
+    readonly error?: ErrorInfo;
+    readonly usage?: Usage;
+}
+export interface PartRow extends Introduced {
+    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;
+}
+export interface CallRow extends Introduced, Ended {
+    readonly callId: string;
+    readonly owner: CallOwner;
+    readonly capability: Capability;
+    readonly input?: JsonValue;
+    readonly inputRef?: ValueReference;
+    readonly inputError?: ErrorInfo;
+    readonly status: "requested" | "running" | "settled";
+    readonly clearedBy?: ClearedBy;
+    readonly taskId?: string;
+    readonly outcome?: CallOutcome;
+    readonly output?: JsonValue;
+    readonly outputRef?: ValueReference;
+    readonly outputOf?: {
+        readonly callId: string;
+    };
+    readonly error?: ErrorInfo;
+    readonly reason?: string;
+    readonly cause?: Cause;
+    /** The call's label once it settled, from the tool; `capability.label` labels it before. */
+    readonly label?: string;
+    /** What the call delegated, such as a child session's model use. */
+    readonly usage?: Usage;
+}
+export interface TaskRow extends Introduced, Ended {
+    readonly taskId: string;
+    readonly startedBy: {
+        readonly callId: string;
+    };
+    readonly kind: string;
+    readonly name: string;
+    readonly status: "running" | "ended";
+    readonly outcome?: TaskOutcome;
+    readonly reason?: string;
+    readonly error?: ErrorInfo;
+}
+export interface InteractionRow extends Introduced, Ended {
+    readonly interactionId: string;
+    readonly subject: InteractionOpenedData["subject"];
+    readonly request: InteractionOpenedData["request"];
+    readonly origin?: InteractionOpenedData["origin"];
+    readonly audience?: InteractionOpenedData["audience"];
+    readonly status: "open" | "settled";
+    readonly outcome?: InteractionOutcome;
+    readonly reason?: string;
+    readonly cause?: Cause;
+    readonly response?: {
+        readonly [key: string]: JsonValue;
+    };
+}
+export interface ResponseRow extends Introduced, Ended {
+    readonly responseId: string;
+    readonly interactionId: string;
+    readonly deliveryId: string;
+    readonly value?: ResponseValue;
+    readonly status: "submitted" | "admitted" | "settled";
+    readonly outcome?: ResponseOutcome;
+    readonly reason?: string;
+}
+export interface ChildRow extends Introduced, ChildOpenedData {
+    /** Deliveries the child accepted for this session's calls, oldest first, from `child.sent`. */
+    readonly deliveries?: readonly {
+        readonly deliveryId: string;
+        readonly callId: string;
+    }[];
+}
+export interface ChangeRow extends Introduced, Ended {
+    readonly changeId: string;
+    readonly kind: ContextKind;
+    readonly turnId?: string;
+    readonly cause?: Cause;
+    readonly trigger?: {
+        readonly inputTokens: number;
+    };
+    readonly status: "running" | "settled";
+    readonly outcome?: ContextOutcome;
+    readonly selects?: null | {
+        readonly turnId: string;
+    };
+    readonly error?: ErrorInfo;
+}
+/** Usage folded into totals, so it never pins the rows that spent it. */
+export interface UsageTotals {
+    readonly total: Usage;
+    readonly byKind: {
+        readonly [kind: string]: Usage;
+    };
+}
+type Table<TRow> = {
+    readonly [id: string]: TRow;
+};
+/**
+ * Private projection state as of one position. Rows are replaced, never edited, when their entity
+ * changes; a missing row means "not retained here", not "never existed".
+ */
+export interface SessionView {
+    /** The number of lines folded: the position of the next line. */
+    readonly position: number;
+    readonly session: SessionRow;
+    readonly deliveries: Table<DeliveryRow>;
+    readonly turns: Table<TurnRow>;
+    readonly runs: Table<RunRow>;
+    readonly parts: Table<PartRow>;
+    readonly calls: Table<CallRow>;
+    readonly tasks: Table<TaskRow>;
+    readonly interactions: Table<InteractionRow>;
+    readonly responses: Table<ResponseRow>;
+    readonly children: Table<ChildRow>;
+    readonly changes: Table<ChangeRow>;
+    readonly usage: UsageTotals;
+    /**
+     * The conversation's selected turn, when a context change chose one: `null` after a clear.
+     * Absent means the newest turn.
+     */
+    readonly selection?: null | {
+        readonly turnId: string;
+    };
+}
+/** What streamed for entities their facts haven't completed yet. Never part of the tables. */
+export interface SessionPreviews {
+    readonly parts: Table<PartPreview>;
+    readonly calls: Table<CallPreview>;
+}
+export interface PartPreview {
+    readonly partId: string;
+    readonly runId?: string;
+    readonly kind: string;
+    readonly text: string;
+}
+export interface CallPreview {
+    readonly callId: string;
+    readonly runId?: string;
+    readonly name: string;
+    /** What the call invokes, as announced; the call's row names its capability. */
+    readonly kind?: CapabilityKind;
+    readonly input: string;
+    /** The latest output snapshot, while the call runs. */
+    readonly output?: JsonValue;
+    /** The call's label for that output, from the tool. */
+    readonly label?: string;
+}
+export {};

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

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