eve 0.83.3 → 0.84.1

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{};

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

@@ -0,0 +1,72 @@
+import type { CallRow, ChangeRow, ChildRow, DeliveryRow, InteractionRow, PartRow, ResponseRow, RunRow, SessionView, TaskRow, TurnRow } from "#protocol/session-projection/tables.js";
+/** The families of entities a session's tables hold. */
+export type Family = "turn" | "run" | "change" | "call" | "task" | "interaction" | "response" | "delivery" | "child" | "part";
+/** One entity: its family and id. */
+export interface Ref {
+    readonly family: Family;
+    readonly id: string;
+}
+interface Rows {
+    readonly turn: TurnRow;
+    readonly run: RunRow;
+    readonly change: ChangeRow;
+    readonly call: CallRow;
+    readonly task: TaskRow;
+    readonly interaction: InteractionRow;
+    readonly response: ResponseRow;
+    readonly delivery: DeliveryRow;
+    readonly child: ChildRow;
+    readonly part: PartRow;
+}
+declare const TABLES: {
+    readonly call: "calls";
+    readonly change: "changes";
+    readonly child: "children";
+    readonly delivery: "deliveries";
+    readonly interaction: "interactions";
+    readonly part: "parts";
+    readonly response: "responses";
+    readonly run: "runs";
+    readonly task: "tasks";
+    readonly turn: "turns";
+};
+/** The table that holds a family's rows. */
+export declare function tableOf(family: Family): (typeof TABLES)[Family];
+export declare function rowOf<F extends Family>(view: SessionView, family: F, id: string): Rows[F] | undefined;
+/** A reference written as on the wire, `{ turnId }` or `{ callId }`, as a `Ref`. */
+export declare function refOf(keyed: Readonly<Record<string, string>> | undefined): Ref | undefined;
+/**
+ * The owner of an entity, whose end ends it; `undefined` for one the session owns. A call
+ * belongs to the run that made it while the run streams; once the run completes, the call goes
+ * on under the run's turn or context change, and a call a task serves belongs to the task. A
+ * delivery belongs to the turn that consumed it.
+ */
+export declare function parentOf(view: SessionView, ref: Ref): Ref | undefined;
+/** An entity's owners, nearest first. Stops at a cycle, which a malformed stream could hold. */
+export declare function ancestors(view: SessionView, ref: Ref): Ref[];
+/** The nearest owner of `family` above an entity, itself included. */
+export declare function ownerOf(view: SessionView, ref: Ref, family: Family): string | undefined;
+/** Whether an entity is open: introduced and not yet closed. */
+export declare function isOpen(view: SessionView, ref: Ref): boolean;
+/**
+ * Every open entity under `owner`, or under the session, leaves first: closing them in this
+ * order closes each before what owns it, and a responder's sign-in before its response.
+ */
+export declare function openUnder(view: SessionView, owner: Ref | "session"): Ref[];
+/**
+ * The owners a fact about an entity belongs to, for readers that don't fold: the turn, task,
+ * run, and change at or above it. A call also names the turn whose run made it, even once a
+ * task serves it.
+ */
+export declare function scopeOf(view: SessionView, ref: Ref): {
+    turnId?: string;
+    taskId?: string;
+    runId?: string;
+    changeId?: string;
+};
+/**
+ * The turn an entity belongs to: the turn at or above it, the turn whose run made a call, or for
+ * what a task owns, the turn whose call started the task.
+ */
+export declare function turnOf(view: SessionView, ref: Ref): string | undefined;
+export {};

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

@@ -0,0 +1 @@
+import{isObject}from"#protocol/session-events/json.js";const TABLES={call:`calls`,change:`changes`,child:`children`,delivery:`deliveries`,interaction:`interactions`,part:`parts`,response:`responses`,run:`runs`,task:`tasks`,turn:`turns`},CLOSABLE=[`interaction`,`response`,`call`,`run`,`task`,`change`,`delivery`,`turn`];function tableOf(e){return TABLES[e]}function rowOf(e,t,n){return e[TABLES[t]][n]}function refOf(e){if(isObject(e)){if(`turnId`in e)return{family:`turn`,id:e.turnId};if(`runId`in e)return{family:`run`,id:e.runId};if(`changeId`in e)return{family:`change`,id:e.changeId};if(`callId`in e)return{family:`call`,id:e.callId};if(`taskId`in e)return{family:`task`,id:e.taskId};if(`responseId`in e)return{family:`response`,id:e.responseId};if(`interactionId`in e)return{family:`interaction`,id:e.interactionId}}}function parentOf(e,t){switch(t.family){case`run`:return refOf(rowOf(e,`run`,t.id)?.owner);case`change`:{let n=rowOf(e,`change`,t.id)?.turnId;return n===void 0?void 0:{family:`turn`,id:n}}case`call`:{let n=rowOf(e,`call`,t.id);if(n===void 0)return;if(n.taskId!==void 0)return{family:`task`,id:n.taskId};let r=refOf(n.owner);if(r?.family!==`run`)return r;let i=rowOf(e,`run`,r.id);return i?.status===`settled`&&i.outcome===`completed`?refOf(i.owner):r}case`interaction`:return refOf(rowOf(e,`interaction`,t.id)?.subject);case`response`:{let n=rowOf(e,`response`,t.id)?.interactionId;return n===void 0?void 0:{family:`interaction`,id:n}}case`delivery`:{let n=rowOf(e,`delivery`,t.id);return n?.status===`consumed`&&n.turnId!==void 0?{family:`turn`,id:n.turnId}:void 0}case`child`:return refOf(rowOf(e,`child`,t.id)?.owner);case`part`:{let n=rowOf(e,`part`,t.id)?.runId;return n===void 0?void 0:{family:`run`,id:n}}case`turn`:case`task`:return}}function ancestors(e,t){let n=[],r=new Set([`${t.family}:${t.id}`]),i=parentOf(e,t);for(;i!==void 0&&!r.has(`${i.family}:${i.id}`);)r.add(`${i.family}:${i.id}`),n.push(i),i=parentOf(e,i);return n}function ownerOf(e,t,n){return t.family===n?t.id:ancestors(e,t).find(e=>e.family===n)?.id}function isOpen(e,t){let n=rowOf(e,t.family,t.id);return n?.status!==void 0&&n.status!==`settled`&&n.status!==`ended`}function openUnder(e,t){let n=[];for(let r of CLOSABLE)for(let[i,a]of Object.entries(e[TABLES[r]])){let o={family:r,id:i};if(!isOpen(e,o))continue;let s=ancestors(e,o);(t===`session`||s.some(e=>e.family===t.family&&e.id===t.id))&&n.push({at:a.introducedAt,depth:s.length,ref:o})}return n.sort((e,t)=>t.depth-e.depth||t.at-e.at).map(e=>e.ref)}function scopeOf(e,t){let n={};for(let r of[t,...ancestors(e,t)])r.family===`turn`?n.turnId??=r.id:r.family===`task`?n.taskId??=r.id:r.family===`run`?n.runId??=r.id:r.family===`change`&&(n.changeId??=r.id);let r=t.family===`call`?refOf(rowOf(e,`call`,t.id)?.owner):void 0;return r!==void 0&&(r.family===`run`&&(n.runId??=r.id),n.turnId??=ownerOf(e,r,`turn`),n.turnId===void 0&&delete n.turnId),n}function turnOf(e,t){let n=scopeOf(e,t);if(n.turnId!==void 0||n.taskId===void 0)return n.turnId;let r=rowOf(e,`task`,n.taskId)?.startedBy.callId;return r===void 0?void 0:scopeOf(e,{family:`call`,id:r}).turnId}export{ancestors,isOpen,openUnder,ownerOf,parentOf,refOf,rowOf,scopeOf,tableOf,turnOf};

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

@@ -1,166 +1,47 @@
-import type { ActionResultError, ApprovalCandidateOutcome, AuthorizationOutcome, AuthorizationPrincipal, UnstampedMessageStreamEvent } from "#protocol/message.js";
-import type { InputRequest, InputResponse } from "#shared/input.js";
-import type { JsonValue } from "#shared/json.js";
-export interface SessionTurn {
-    readonly turnId: string;
-    readonly sequence: number;
-    readonly status: "active" | "completed" | "cancelled" | "failed";
-    /** The open turn is parked, holding on its tasks or on a person: a sign-in, approval, or question. */
-    readonly waiting?: boolean;
-    /** The step the turn's latest `step.started` opened; absent before its first. */
-    readonly stepIndex?: number;
-    /** The turn streamed assistant output, so steering can no longer restart it. */
-    readonly outputStarted?: boolean;
-}
-export interface SessionInput {
-    readonly request: InputRequest;
-    readonly sequence: number;
-    readonly turnId: string;
-    readonly stepIndex: number;
-    /** The task whose run asks, when a task asks. */
-    readonly taskId?: string;
-    /** The call a relayed request serves. */
-    readonly callId?: string;
-    /** `responded` is client-only: an answer this client sent that the stream hasn't settled. */
-    readonly status: "open" | "responded" | "settled";
-    readonly response?: InputResponse;
-    readonly outcome?: string;
-}
-/** One call that started or reached a task, settled by its `task.settled`. */
-export interface ConversationTaskCall {
-    readonly callId: string;
-    readonly turnId: string;
-    readonly status: "working" | "completed" | "failed" | "cancelled";
-    /** The call's result; present only when `status` is `"completed"`. */
-    readonly output?: JsonValue;
-    /** Why the call failed; present only when `status` is `"failed"`. */
-    readonly error?: {
-        readonly message: string;
-    };
-}
-export interface ConversationTask {
-    readonly taskId: string;
-    /** The tool whose call started the task. */
-    readonly name: string;
-    /**
-     * `"agent"` when a subagent's tool, local or remote, started the task; `"tool"` for an authored
-     * tool, including one that opens sessions with `ctx.agent`.
-     */
-    readonly kind: "agent" | "tool";
-    /** Calls in the order they started or reached the task. */
-    readonly calls: Readonly<Record<string, ConversationTaskCall>>;
-}
-/**
- * Where a call stands, as the stream reports it. A task call runs until its `task.settled`,
- * not until the receipt the model reads.
- */
-export type SessionCallStatus = "running" | "awaiting-input" | "completed" | "failed" | "rejected" | "cancelled";
-interface SessionCallFields {
-    readonly callId: string;
-    /** The tool, subagent, or skill the call invokes. */
-    readonly name: string;
-    readonly turnId: string;
-    readonly stepIndex: number;
-    /** The approval request the call awaits, or awaited. */
-    readonly requestId?: string;
-}
-/**
- * One call the session made. A call that started or reached a task keeps only the link to it:
- * the task's call record is where it stands, so the projection holds each outcome once.
- */
-export type SessionCall = SessionCallFields & ({
-    readonly status: SessionCallStatus;
-    readonly error?: ActionResultError;
-    readonly taskId?: undefined;
-} | {
-    readonly taskId: string;
-    readonly status?: undefined;
-    readonly error?: undefined;
-});
-export interface SessionAuthorization {
-    /** The attempt's `attemptId`, or its connection name from a writer that sent none. */
-    readonly attemptId: string;
-    readonly name: string;
-    readonly sequence: number;
-    readonly turnId: string;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly principalId?: string;
-    /** The approval candidate whose responder signs in. */
-    readonly candidateId?: string;
-    /** The credential the sign-in grants, which every scope that uses it shares. */
-    readonly grant?: string;
-    readonly principal?: AuthorizationPrincipal;
-    readonly status: "required" | AuthorizationOutcome;
-    /** A `failed` sign-in that reported `retryable: false`: the turn reports it, not asks again. */
-    readonly retryable?: boolean;
-    /** Why a `failed` sign-in failed, as its completion reported it. */
-    readonly reason?: string;
-    /** The sign-in resumes its work through a callback, rather than inline. */
-    readonly awaitsCallback?: true;
-}
-/** One responder's decision on an approval, as `approval.candidate` reports it. */
-export interface SessionApprovalCandidate {
-    readonly candidateId: string;
-    readonly requestId: string;
-    readonly outcome: ApprovalCandidateOutcome;
-}
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { Usage } from "#protocol/session-events/envelope.js";
+import type { SessionView } from "#protocol/session-projection/tables.js";
 export interface SessionProjection {
-    /** `session.started` was published. */
-    readonly started?: true;
-    /** The session ended with `session.completed` or `session.failed`. */
-    readonly ended?: true;
-    readonly activeTurnId?: string;
-    /** The sequence the next turn takes. */
-    readonly nextSequence: number;
-    readonly turns: Readonly<Record<string, SessionTurn>>;
-    /** By `requestId`. */
-    readonly inputs: Readonly<Record<string, SessionInput>>;
-    /** By `taskId`. */
-    readonly tasks: Readonly<Record<string, ConversationTask>>;
-    /** By `callId`. */
-    readonly calls: Readonly<Record<string, SessionCall>>;
-    /** By `attemptId`. */
-    readonly authorizations: Readonly<Record<string, SessionAuthorization>>;
-    /** By `candidateId`. */
-    readonly candidates: Readonly<Record<string, SessionApprovalCandidate>>;
+    /** The public view, kept with operational retention; its `position` is the next line's. */
+    readonly view: SessionView;
+    /** Runs and context changes minted so far, so their ids are deterministic. */
+    readonly counters: {
+        readonly runs: number;
+        readonly changes: number;
+    };
+    /** The turn that streamed output, so steering can no longer restart it. */
+    readonly outputStarted?: string;
+    /** The latest own budget acceptance, anchored at its commit's spend; retained after rows prune. */
+    readonly usageWindow?: {
+        readonly interactionId: string;
+        readonly index: number;
+        readonly start: Usage;
+    };
 }
 export declare function initialSessionProjection(): SessionProjection;
-export declare function isSettledCallStatus(status: SessionCallStatus): boolean;
-/**
- * Folds one stream event into a session's lifecycle. Events this fold doesn't track, and
- * client-only events, return `state` unchanged, so callers may pass any event through it.
- */
-export declare function foldSession<S extends SessionProjection>(state: S, event: UnstampedMessageStreamEvent | {
-    readonly type: string;
-}): S;
+/** Folds a line's observations beside its already-folded view. */
+export declare function foldSession<S extends SessionProjection>(state: S, events: readonly SessionEvent[]): S;
+/** The open turn's id, if one is open. */
+export declare function activeTurnIdOf(state: SessionProjection): string | undefined;
+/** The session's newest turn, open or closed. */
+export declare function latestTurnIdOf(state: SessionProjection): string | undefined;
+/** The turn a run serves, if a turn owns it. */
+export declare function runTurnId(state: SessionProjection, runId: string): string | undefined;
+/** The id the session's next model run takes. */
+export declare function nextRunId(state: SessionProjection): string;
+/** The id the session's next context change takes. */
+export declare function nextChangeId(state: SessionProjection): string;
+/** The open run that serves a turn: its latest run not yet settled. */
+export declare function openRunOf(state: SessionProjection, turnId: string): string | undefined;
 /** The coordinates the active turn's events carry, or the next turn's when none is open. */
 export declare function turnCoordinates(state: SessionProjection): {
     readonly sequence: number;
     readonly stepIndex: number;
     readonly turnId: string;
 };
-/** Inputs awaiting an answer, including requests introduced in earlier turns. */
-export declare function openInputs(state: SessionProjection): readonly SessionInput[];
-/** Sign-ins the session still waits on. */
-export declare function openSignIns(state: SessionProjection): readonly SessionAuthorization[];
-/** Task calls whose run hasn't settled them. */
-export declare function workingTaskCalls(state: SessionProjection): readonly ConversationTaskCall[];
-/**
- * A call's status for a reader. A call still running when its turn ended, or when the reader's
- * stream stopped (`streaming: false`), reads as `interrupted`; a task call runs past its turn.
- */
-export declare function callStatus(state: SessionProjection, callId: string, options?: {
-    readonly streaming?: boolean;
-}): SessionCallStatus | "interrupted" | undefined;
-/** A call's status as the stream reported it: a task call's is its task call's. */
-export declare function reportedCallStatus(state: SessionProjection, call: SessionCall): SessionCallStatus;
-/**
- * Drops what closed, so a long-lived session's stored projection stays proportional to its
- * open work. `keep` names closed requests and calls that execution state still references.
- */
-export declare function pruneSessionProjection(state: SessionProjection, keep?: {
-    readonly requestIds?: Iterable<string>;
-    readonly callIds?: Iterable<string>;
-}): SessionProjection;
-export {};
+/** Where a turn's events go: its sequence and its latest step. */
+export declare function turnCoordinatesOf(state: SessionProjection, turnId: string): {
+    readonly sequence: number;
+    readonly stepIndex: number;
+    readonly turnId: string;
+};

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

@@ -1 +1 @@
-function initialSessionProjection(){return{authorizations:{},calls:{},candidates:{},inputs:{},nextSequence:0,tasks:{},turns:{}}}function updateTurn(e,t,n){let r=e.turns[t];if(r===void 0)return e;let i=n(r);return i===r?e:{...e,turns:{...e.turns,[t]:i}}}function putTask(e,t){return e.tasks[t.taskId]===t?e:{...e,tasks:{...e.tasks,[t.taskId]:t}}}function putTaskCall(e,t){return e.calls[t.callId]===t?e:{...e,calls:{...e.calls,[t.callId]:t}}}function putCall(e,t){return e.calls[t.callId]===t?e:{...e,calls:{...e.calls,[t.callId]:t}}}function updateTask(e,t,n){let r=e.tasks[t];return r===void 0?e:putTask(e,n(r))}function updateCall(e,t,n){let r=e.calls[t];return r===void 0?e:putCall(e,n(r))}const SETTLED_CALL_STATUSES=new Set([`completed`,`failed`,`rejected`,`cancelled`]);function isSettledCallStatus(e){return SETTLED_CALL_STATUSES.has(e)}function settleCall(e,t,n){if(e.taskId!==void 0||isSettledCallStatus(e.status))return e;let{requestId:r,error:i,...a}=e,o={...a,status:t};return e.requestId!==void 0&&(o.requestId=e.requestId),n!==void 0&&(o.error=n),o}function actionName(e){switch(e.kind){case`load-skill`:return e.name;case`subagent-call`:case`remote-agent-call`:return e.name;case`tool-call`:case`workflow-tool-call`:return e.toolName}}function resultName(e){switch(e.kind){case`load-skill-result`:return e.name;case`subagent-result`:return e.subagentName;default:return e.toolName}}function callStatusAfterApproval(e){switch(e){case`approved`:return`running`;case`denied`:return`rejected`;case`cancelled`:return`cancelled`;default:return}}function foldSession(e,t){let n=t;switch(n.type){case`session.started`:return e.started?e:{...e,started:!0};case`turn.started`:{let{sequence:t,turnId:r}=n.data,i={turnId:r,sequence:t,status:`active`};return{...e,activeTurnId:r,nextSequence:Math.max(e.nextSequence,t+1),turns:{...e.turns,[r]:i}}}case`step.started`:return updateTurn(e,n.data.turnId,e=>{if(!e.waiting&&e.stepIndex===n.data.stepIndex)return e;let{waiting:t,...r}=e;return{...r,stepIndex:n.data.stepIndex}});case`turn.waiting`:return updateTurn(e,n.data.turnId,e=>e.status===`active`&&!e.waiting?{...e,waiting:!0}:e);case`message.appended`:case`message.completed`:case`result.completed`:return(n.type===`message.appended`?n.data.messageDelta.length>0:n.type!==`message.completed`||(n.data.message?.length??0)>0)?updateTurn(e,n.data.turnId,e=>e.outputStarted?e:{...e,outputStarted:!0}):e;case`turn.completed`:case`turn.cancelled`:case`turn.failed`:{let{turnId:t}=n.data,r=n.type===`turn.completed`?`completed`:n.type===`turn.failed`?`failed`:`cancelled`,{waiting:i,...a}=e.turns[t]??{turnId:t,sequence:n.data.sequence};return{...e,activeTurnId:e.activeTurnId===t?void 0:e.activeTurnId,turns:{...e.turns,[t]:{...a,status:r}}}}case`context.cleared`:return{...e,calls:Object.fromEntries(Object.entries(e.calls).filter(([,e])=>e.taskId!==void 0))};case`session.waiting`:return e.activeTurnId===void 0?e:{...e,activeTurnId:void 0};case`session.completed`:case`session.failed`:{let{activeTurnId:t,...n}=e;return{...n,ended:!0}}case`actions.requested`:{let t;for(let r of n.data.actions)e.calls[r.callId]===void 0&&(t??={...e.calls},t[r.callId]={callId:r.callId,name:actionName(r),turnId:n.data.turnId,stepIndex:n.data.stepIndex,status:`running`});return t===void 0?e:{...e,calls:t}}case`action.result`:{let{result:t,status:r,error:i}=n.data,a=e.calls[t.callId];if(a?.taskId!==void 0)return e;let o=r===`rejected`||i?.code===`TOOL_EXECUTION_DENIED`?`rejected`:r===`failed`||t.isError===!0?`failed`:`completed`;if(a===void 0){let r={callId:t.callId,name:resultName(t),turnId:n.data.turnId,stepIndex:n.data.stepIndex,status:o};return i!==void 0&&(r.error=i),putCall(e,r)}return updateCall(e,t.callId,e=>settleCall(e,o,i))}case`task.started`:{let{callId:t,kind:r,name:i,taskId:a,turnId:o}=n.data,s=e.tasks[a]??{taskId:a,name:i,kind:r,calls:{}},c=e;s.calls[t]===void 0&&(c=putTask(c,putTaskCall(s,{callId:t,turnId:o,status:`working`})));let l=c.calls[t];if(l?.taskId===a)return c;let u={callId:t,name:l?.name??i,stepIndex:l?.stepIndex??0,taskId:a,turnId:l?.turnId??o};return l?.requestId!==void 0&&(u.requestId=l.requestId),putCall(c,u)}case`task.settled`:{let{callId:t,error:r,output:i,status:a,taskId:o}=n.data;return updateTask(e,o,e=>{let n=e.calls[t];if(n===void 0||n.status!==`working`)return e;let o={callId:t,turnId:n.turnId,status:a};return putTaskCall(e,a===`completed`&&i!==void 0?{...o,output:i}:a===`failed`&&r!==void 0?{...o,error:r}:o)})}case`input.requested`:{let t={...e.inputs},r;for(let i of n.data.requests){if(t[i.requestId]!==void 0)continue;let a={request:i,sequence:n.data.sequence,turnId:n.data.turnId,stepIndex:n.data.stepIndex,status:`open`};if(n.data.taskId!==void 0&&(a.taskId=n.data.taskId),n.data.callId!==void 0&&(a.callId=n.data.callId),t[i.requestId]=a,i.kind!==`tool-approval`||isRelayed(n.data))continue;let{callId:o,toolName:s}=i.action;r??={...e.calls};let c=r[o];c?.taskId===void 0&&(c!==void 0&&isSettledCallStatus(c.status)||(r[o]={...c??{callId:o,name:s,turnId:n.data.turnId,stepIndex:n.data.stepIndex},requestId:i.requestId,status:`awaiting-input`}))}return r===void 0?{...e,inputs:t}:{...e,calls:r,inputs:t}}case`approval.candidate`:{let{candidateId:t,outcome:r,requestId:i}=n.data;e={...e,candidates:{...e.candidates,[t]:{candidateId:t,outcome:r,requestId:i}}};let a=e.inputs[n.data.requestId];if(a===void 0||a.status===`settled`||n.data.outcome===`pending`||a.status===`open`)return e;let{response:o,...s}=a;return{...e,inputs:{...e.inputs,[n.data.requestId]:{...s,status:`open`}}}}case`approval.settled`:{let t=e.inputs[n.data.requestId];if(t===void 0||t.status===`settled`)return e;let r=n.data.outcome===`approved`?`approved`:`denied`;return settleApprovalCall({...e,inputs:{...e.inputs,[n.data.requestId]:{...t,status:`settled`,outcome:r}}},t,r)}case`input.resolved`:{let t=e;for(let e of n.data.resolutions){let n=t.inputs[e.requestId];if(n===void 0||n.status===`settled`)continue;let r=e.response??n.response,i={...n,status:`settled`,outcome:e.outcome};r!==void 0&&(i.response=r),t={...t,inputs:{...t.inputs,[e.requestId]:i}},t=settleApprovalCall(t,n,e.outcome)}return t}case`authorization.required`:{let t=n.data.attemptId??n.data.name,r={attemptId:t,name:n.data.name,sequence:n.data.sequence,turnId:n.data.turnId,stepIndex:n.data.stepIndex,status:`required`};return n.data.taskId!==void 0&&(r.taskId=n.data.taskId),n.data.principalId!==void 0&&(r.principalId=n.data.principalId),n.data.candidateId!==void 0&&(r.candidateId=n.data.candidateId),n.data.grant!==void 0&&(r.grant=n.data.grant),n.data.principal!==void 0&&(r.principal=n.data.principal),n.data.webhookUrl!==void 0&&(r.awaitsCallback=!0),{...e,authorizations:{...e.authorizations,[t]:r}}}case`authorization.completed`:{let t=n.data.attemptId??n.data.name,r={...e.authorizations[t]??{attemptId:t,name:n.data.name,sequence:n.data.sequence,turnId:n.data.turnId,stepIndex:n.data.stepIndex},status:n.data.outcome};return n.data.grant!==void 0&&(r.grant=n.data.grant),n.data.principal!==void 0&&(r.principal=n.data.principal),n.data.retryable!==void 0&&(r.retryable=n.data.retryable),n.data.reason!==void 0&&(r.reason=n.data.reason),{...e,authorizations:{...e.authorizations,[t]:r}}}default:return e}}function isRelayed(e){return e.callId!==void 0||e.taskId!==void 0}function settleApprovalCall(e,t,n){if(t.request.kind!==`tool-approval`||isRelayed(t))return e;let r=callStatusAfterApproval(n);return r===void 0?e:updateCall(e,t.request.action.callId,e=>e.status!==`awaiting-input`||e.requestId!==t.request.requestId?e:r===`running`?{...e,status:r}:settleCall(e,r))}function turnCoordinates(e){let t=e.activeTurnId===void 0?void 0:e.turns[e.activeTurnId];return t===void 0?{sequence:e.nextSequence,stepIndex:0,turnId:`turn_${e.nextSequence}`}:{sequence:t.sequence,stepIndex:t.stepIndex??0,turnId:t.turnId}}function openInputs(e){return Object.values(e.inputs).filter(e=>e.status!==`settled`)}function openSignIns(e){return Object.values(e.authorizations).filter(e=>e.status===`required`)}function workingTaskCalls(e){return Object.values(e.tasks).flatMap(e=>Object.values(e.calls).filter(e=>e.status===`working`))}function callStatus(e,t,n={}){let r=e.calls[t];if(r===void 0)return;let i=reportedCallStatus(e,r);if(i!==`running`||r.taskId!==void 0)return i;let a=e.turns[r.turnId];return n.streaming===!1||a!==void 0&&a.status!==`active`?`interrupted`:i}function reportedCallStatus(e,t){if(t.taskId===void 0)return t.status;let n=e.tasks[t.taskId]?.calls[t.callId]?.status;return n===void 0||n===`working`?`running`:n}function pruneSessionProjection(e,t={}){let n=new Set(t.requestIds),r=new Set(t.callIds),i=Object.fromEntries(Object.entries(e.calls).filter(([t,i])=>!isSettledCallStatus(reportedCallStatus(e,i))&&callStatus(e,t)!==`interrupted`||r.has(t)||i.requestId!==void 0&&n.has(i.requestId)));for(let e of Object.values(i))e.requestId!==void 0&&n.add(e.requestId);let a=Object.fromEntries(Object.entries(e.inputs).filter(([e,t])=>t.status!==`settled`||n.has(e))),o=new Set(Object.values(i).flatMap(e=>e.taskId===void 0?[]:[e.callId])),s={};for(let[t,n]of Object.entries(e.tasks)){let e=Object.entries(n.calls).filter(([e,t])=>t.status===`working`||o.has(e));e.length>0&&(s[t]={...n,calls:Object.fromEntries(e)})}let c=Object.fromEntries(Object.entries(e.authorizations).filter(([,e])=>e.status===`required`)),l=new Set([...e.activeTurnId===void 0?[]:[e.activeTurnId],...Object.values(a).map(e=>e.turnId),...Object.values(i).map(e=>e.turnId),...Object.values(c).map(e=>e.turnId)]),u=Object.fromEntries(Object.entries(e.turns).filter(([e])=>l.has(e))),d=Object.fromEntries(Object.entries(e.candidates).filter(([,e])=>e.requestId in a));return{...e,authorizations:c,calls:i,candidates:d,inputs:a,tasks:s,turns:u}}export{callStatus,foldSession,initialSessionProjection,isSettledCallStatus,openInputs,openSignIns,pruneSessionProjection,reportedCallStatus,turnCoordinates,workingTaskCalls};
+import{emptySessionView}from"#protocol/session-projection/fold.js";import{activeTurn}from"#protocol/session-projection/selectors.js";function initialSessionProjection(){return{counters:{changes:0,runs:0},view:emptySessionView()}}function foldSession(e,t){let n=new Set;for(let r of t)switch(r.type){case`model.requested`:e={...e,counters:{...e.counters,runs:e.counters.runs+1}};break;case`context.started`:e={...e,counters:{...e.counters,changes:e.counters.changes+1}};break;case`interaction.settled`:{let t=e.view.interactions[r.data.interactionId];if(t?.request.kind!==`budget`||t.origin!==void 0||!(`turnId`in t.subject)||t.outcome!==`accepted`||r.data.outcome!==`accepted`||t.closedAt!==e.view.position-1||n.has(t.interactionId))break;n.add(t.interactionId),e={...e,usageWindow:{interactionId:t.interactionId,index:(e.usageWindow?.index??0)+1,start:e.view.usage.total}};break}case`content.delta`:r.data.kind===`text`&&r.data.delta.length>0&&(e=markOutputStarted(e,r.scope?.runId));break;case`content.completed`:{let{kind:t,runId:n,value:i}=r.data;(t===`result`||t===`text`&&typeof i==`string`&&i.length>0)&&(e=markOutputStarted(e,n));break}}return e}function markOutputStarted(e,t){let n=t===void 0?activeTurnIdOf(e):runTurnId(e,t);return n===void 0||e.outputStarted===n?e:{...e,outputStarted:n}}function activeTurnIdOf(e){return activeTurn(e.view)?.turnId}function latestTurnIdOf(e){return e.view.session.latestTurnId}function runTurnId(e,t){let n=e.view.runs[t]?.owner;return n!==void 0&&`turnId`in n?n.turnId:void 0}function nextRunId(e){return`run_${String(e.counters.runs)}`}function nextChangeId(e){return`change_${String(e.counters.changes)}`}function openRunOf(e,t){let n;for(let r of Object.values(e.view.runs)){if(r.status===`settled`||!(`turnId`in r.owner)||r.owner.turnId!==t)continue;let e=r.step??0;(n===void 0||e>=n.step)&&(n={runId:r.runId,step:e})}return n?.runId}function turnSequence(e){let t=/^turn_(\d+)$/.exec(e);return t===null?void 0:Number(t[1])}function turnCoordinates(e){let t=activeTurnIdOf(e);if(t!==void 0)return turnCoordinatesOf(e,t);let n=e.view.session.turnCount;return{sequence:n,stepIndex:0,turnId:`turn_${n}`}}function turnCoordinatesOf(e,t){let n=e.view.turns[t]?.runs??0,{latestTurnId:r,turnCount:i}=e.view.session;return{sequence:(t===r?Math.max(0,i-1):void 0)??turnSequence(t)??Math.max(0,i-1),stepIndex:Math.max(0,n-1),turnId:t}}export{activeTurnIdOf,foldSession,initialSessionProjection,latestTurnIdOf,nextChangeId,nextRunId,openRunOf,runTurnId,turnCoordinates,turnCoordinatesOf};

package/dist/src/protocol/task-tools.d.ts

@@ -1,4 +1,4 @@
-import type { ActionResultStreamEvent } from "#protocol/message.js";
+import type { FactOf } from "#protocol/session-events/facts.js";
 export declare const TASK_WAIT_TOOL_NAME = "eve__task_wait";
 export declare const TASK_CANCEL_TOOL_NAME = "eve__task_cancel";
 /** The task tools' names. */
@@ -13,9 +13,11 @@ export declare function isTaskControlTool(toolName: string): boolean;
 export declare const TOO_MANY_TASKS_CODE = "TOO_MANY_TASKS";
 export declare const UNKNOWN_TASK_CODE = "UNKNOWN_TASK";
 /**
- * Whether a tool result is the session refusing a task call for the model
- * to retry. Its message tells the model how to recover, so activity surfaces
- * keep it out of view. Only a failed result counts: an authored tool can
- * return the same `code` as ordinary output.
+ * A framework task admission refused the call before starting any work. The lifecycle says so;
+ * an authored tool's output or error code never decides admission. Activity surfaces hide these
+ * refusals while the model follows their recovery guidance.
  */
-export declare function isTaskRetryRefusal(event: ActionResultStreamEvent): boolean;
+export declare function isTaskAdmissionRefused(call: {
+    readonly outcome?: string;
+    readonly cause?: FactOf<"call.settled">["data"]["cause"];
+}): boolean;

package/dist/src/protocol/task-tools.js

@@ -1 +1 @@
-const TASK_WAIT_TOOL_NAME=`eve__task_wait`,TASK_CANCEL_TOOL_NAME=`eve__task_cancel`,TASK_TOOL_NAMES=[TASK_WAIT_TOOL_NAME,TASK_CANCEL_TOOL_NAME];function isTaskControlTool(e){return TASK_TOOL_NAMES.includes(e)}const TOO_MANY_TASKS_CODE=`TOO_MANY_TASKS`,UNKNOWN_TASK_CODE=`UNKNOWN_TASK`,TASK_RETRY_ERROR_CODES=[TOO_MANY_TASKS_CODE,UNKNOWN_TASK_CODE];function isTaskRetryRefusal(e){if(e.data.status!==`failed`||e.data.result.kind!==`tool-result`)return!1;let t=e.data.result.output;if(typeof t!=`object`||!t)return!1;let n=Reflect.get(t,`code`);return typeof n==`string`&&TASK_RETRY_ERROR_CODES.includes(n)}export{TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_WAIT_TOOL_NAME,TOO_MANY_TASKS_CODE,UNKNOWN_TASK_CODE,isTaskControlTool,isTaskRetryRefusal};
+const TASK_WAIT_TOOL_NAME=`eve__task_wait`,TASK_CANCEL_TOOL_NAME=`eve__task_cancel`,TASK_TOOL_NAMES=[TASK_WAIT_TOOL_NAME,TASK_CANCEL_TOOL_NAME];function isTaskControlTool(e){return TASK_TOOL_NAMES.includes(e)}const TOO_MANY_TASKS_CODE=`TOO_MANY_TASKS`,UNKNOWN_TASK_CODE=`UNKNOWN_TASK`;function isTaskAdmissionRefused(e){let{outcome:t,cause:n}=e;return t===`rejected`&&n!==void 0&&`policy`in n&&(n.policy===`task-limit`||n.policy===`task-unavailable`)}export{TASK_CANCEL_TOOL_NAME,TASK_TOOL_NAMES,TASK_WAIT_TOOL_NAME,TOO_MANY_TASKS_CODE,UNKNOWN_TASK_CODE,isTaskAdmissionRefused,isTaskControlTool};

package/dist/src/protocol/v26-interactions.d.ts

@@ -0,0 +1,11 @@
+import type { InteractionOutcome, InteractionRequest } from "#protocol/session-events/families/interaction.js";
+type Data = Readonly<Record<string, unknown>>;
+/** A v26 question, tool approval, or session limit as the request a v27 reader shows. */
+export declare function v26InteractionRequest(request: Data): InteractionRequest;
+/** How a v26 resolution's outcome settles the interaction it resolved. */
+export declare function v26InteractionOutcome(outcome: unknown): InteractionOutcome;
+/** A v26 `authorization.required` event's data as the sign-in a v27 reader shows. */
+export declare function v26SignInRequest(data: Data): InteractionRequest;
+/** How a v26 `authorization.completed` outcome settles its sign-in. */
+export declare function v26SignInOutcome(outcome: unknown): InteractionOutcome;
+export {};

package/dist/src/protocol/v26-interactions.js

@@ -0,0 +1 @@
+function v26InteractionRequest(e){let t=e.kind===`tool-approval`?`approval`:e.kind===`session-limit`?`budget`:`question`,n=Array.isArray(e.options)?e.options.flatMap(e=>isRecord(e)&&typeof e.id==`string`&&typeof e.label==`string`?[{id:e.id,label:e.label,description:str(e.description),style:e.style===`primary`||e.style===`danger`||e.style==="default"?e.style:void 0}]:[]):void 0,r=e.display;return{allowFreeform:typeof e.allowFreeform==`boolean`?e.allowFreeform:void 0,display:r===`confirmation`||r===`select`||r===`text`?r:void 0,kind:t,options:n,prompt:str(e.prompt)??``}}function v26InteractionOutcome(e){switch(e){case`answered`:case`approved`:return`accepted`;case`denied`:return`declined`;case`invalid`:return`invalid`;default:return`withdrawn`}}function v26SignInRequest(e){let t=isRecord(e.authorization)?e.authorization:{},n=str(e.name)??`sign-in`,r=str(t.url);return{kind:`sign-in`,link:r===void 0?void 0:{url:r},prompt:str(e.description)??`Sign in to ${n}.`,signIn:{callbackUrl:str(e.webhookUrl),displayName:str(t.displayName),expiresAt:str(t.expiresAt),grant:str(e.grant),instructions:str(t.instructions),name:n,principal:isRecord(e.principal)&&typeof e.principal.type==`string`?{id:str(e.principal.id),issuer:str(e.principal.issuer),type:e.principal.type}:void 0,url:r,userCode:str(t.userCode)}}}function v26SignInOutcome(e){return e===`authorized`?`accepted`:e===`declined`?`declined`:e===`timed-out`?`expired`:`failed`}function str(e){return typeof e==`string`?e:void 0}function isRecord(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}export{v26InteractionOutcome,v26InteractionRequest,v26SignInOutcome,v26SignInRequest};

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

@@ -0,0 +1,5 @@
+/**
+ * True for a record an eve before v27 stored: a v26 `{type, data, meta}` event. No v27 line has a
+ * top-level `type`, so a stream whose first line is one was started by an earlier eve.
+ */
+export declare function isV26Line(record: unknown): boolean;

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

@@ -0,0 +1 @@
+import{isStoredLine}from"./session-events/envelope.js";function isV26Line(e){return typeof e==`object`&&!!e&&!Array.isArray(e)&&typeof e.type==`string`&&!isStoredLine(e)}export{isV26Line};

package/dist/src/public/agents/auth.d.ts

@@ -2,7 +2,7 @@ import { type TokenValue } from "#client/types.js";
 /**
  * Outbound request auth hook for remote agent dispatch. Runs once per
  * outbound request; returns the headers (e.g. `authorization`) to merge onto
- * that request. Use {@link vercelOidc}, {@link bearer}, or {@link basic} to
+ * that request. Use {@link vercelOidc}, {@link bearer}, or {@link httpBasic} to
  * construct one, or supply a custom function for other schemes.
  */
 export type OutboundAuthFn = () => Promise<{
@@ -44,7 +44,7 @@ export declare function bearer(token: TokenValue): OutboundAuthFn;
  * (static string or per-request resolver). Base64-encodes the credentials per
  * request.
  */
-export declare function basic(input: {
+export declare function httpBasic(input: {
     readonly password: TokenValue;
     readonly username: string;
 }): OutboundAuthFn;