eve 0.83.3 → 0.84.0

package/dist/src/harness/session-machine/state.d.ts

@@ -1,23 +1,46 @@
 import type { ModelMessage } from "ai";
+import type { RememberedApproval, RememberRequest } from "#approval/evaluation.js";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
 import type { SessionAuthContext } from "#channel/types.js";
-import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { SessionStateMap, HarnessStepInput } from "#harness/types.js";
 import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
-import type { InputRequest } from "#shared/input.js";
+import type { InteractionRequest } from "#protocol/session-events/families/interaction.js";
+import type { JsonObject } from "#shared/json.js";
 /** The coordinates of the model step a suspended step parked from. */
 export interface StepCoordinates {
     readonly sequence: number;
     readonly stepIndex: number;
     readonly turnId: string;
 }
+/** A call that needs a person's approval, and what they're asked. */
+export interface ApprovalAsk {
+    readonly remember?: RememberRequest;
+    readonly interactionId: string;
+    readonly call: {
+        readonly callId: string;
+        readonly toolName: string;
+        readonly input: JsonObject;
+        /** The dynamic entry's version the call was made from. */
+        readonly version?: string;
+    };
+    readonly request: InteractionRequest;
+}
 /**
- * A call that runs on the turn's next model call, whatever asked for it: a person approved it, or
- * the sign-ins it waited on called back.
+ * A call cleared to run: a person approved it, or nothing asked them to. One a sign-in stopped
+ * waits in its step until the sign-ins it lists call back, then runs as the call that asked.
  */
-export type ApprovedCall = Pick<InputRequest, "action" | "requestId"> & {
+export interface ApprovedCall {
+    readonly call: ApprovalAsk["call"];
+    /** The approval that cleared the call; absent for a call only sign-ins stopped. */
+    readonly interactionId?: string;
     /** The sign-ins the call stopped on: its outcome settles them. */
     readonly signIns?: readonly AuthorizationChallenge[];
-};
+    /**
+     * Who approved it, when a response policy allowed their answer. The call reads it when it
+     * runs, after the answer, and the responder's record with it, has settled.
+     */
+    readonly responder?: SessionAuthContext;
+}
 /**
  * A model step whose calls can't all settle yet: some await an approval or a sign-in, others the
  * runtime.
@@ -28,13 +51,14 @@ export interface SuspendedStep {
     readonly event: StepCoordinates;
     /** The withheld response. Results join it as they arrive. */
     readonly messages: readonly ModelMessage[];
-    /** Approvals the step still waits on. */
-    readonly requests: readonly InputRequest[];
     /**
-     * Calls a person approved that haven't run. They run when the turn next calls the model, after
-     * its step starts and its budget allows it, as calls the model makes do. A call a sign-in
-     * stopped is one of them, once the sign-ins it lists have called back, so the call that asked
-     * runs, rather than the model deciding again.
+     * The approvals the response's calls asked for. How each was answered is the session's
+     * interaction and response tables'; this only remembers what was asked.
+     */
+    readonly requests: readonly ApprovalAsk[];
+    /**
+     * Calls a sign-in stopped. Each stays open, without a result, until the sign-ins it lists have
+     * called back, then runs as the call that asked, rather than the model deciding again.
      */
     readonly approved?: readonly ApprovedCall[];
     /** Workflow and agent calls the runtime runs for the step. */
@@ -44,11 +68,14 @@ export interface SuspendedStep {
     readonly requester?: SessionAuthContext | null;
 }
 export interface TurnState {
-    /** Input that arrived before it could run: a partial answer, or input behind a policy pass. */
-    readonly queued?: StepInput;
+    /**
+     * Turn input that arrived before the turn could take it: behind a question a message can't
+     * steer past, such as the budget prompt, or behind approved calls the model reads first.
+     */
+    readonly queued?: HarnessStepInput;
     readonly suspended: readonly SuspendedStep[];
-    /** Approval keys a `once()` approval granted for the rest of the session. */
-    readonly grants: readonly string[];
+    /** People's approval decisions, under the keys their requests named, for the session. */
+    readonly remembered: Readonly<Record<string, RememberedApproval>>;
 }
 export declare const EMPTY_TURN_STATE: TurnState;
 export declare function readTurnState(state: SessionStateMap | undefined): TurnState;

package/dist/src/harness/session-machine/state.js

@@ -1 +1 @@
-const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={grants:[],suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&t.grants.length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};
+const TURN_STATE_KEY=`eve.harness.turnState`,EMPTY_TURN_STATE={remembered:{},suspended:[]};function readTurnState(e){return e?.[TURN_STATE_KEY]??EMPTY_TURN_STATE}function writeTurnState(e,t){let n={...e.state};return t.suspended.length===0&&t.queued===void 0&&Object.keys(t.remembered).length===0?delete n[TURN_STATE_KEY]:n[TURN_STATE_KEY]=t,{...e,state:Object.keys(n).length===0?void 0:n}}export{EMPTY_TURN_STATE,readTurnState,writeTurnState};

package/dist/src/harness/session-machine/suspended-steps.d.ts

@@ -0,0 +1,22 @@
+import type { ModelMessage } from "ai";
+import type { SuspendedStep, TurnState } from "./state.js";
+type ToolResponsePart = Extract<ModelMessage, {
+    role: "tool";
+}>["content"][number];
+export type ToolResultPart = Extract<ToolResponsePart, {
+    type: "tool-result";
+}>;
+/** The turn with `step` suspended after the steps it already holds. */
+export declare function suspend(turn: TurnState, step: SuspendedStep): TurnState;
+/** The ids of the calls a step's response made, except provider-executed ones. */
+export declare function stepCallIds(step: Pick<SuspendedStep, "messages">): ReadonlySet<string>;
+/** Every call the step made has a result: a pending approval's call has none yet. */
+export declare function isComplete(step: SuspendedStep): boolean;
+/**
+ * Places a result right after the message that made its call, under the call's name: a call
+ * made through `eve__tool` or `eve__skill` keeps that name in history, whatever entry it ran.
+ */
+export declare function withResult(messages: readonly ModelMessage[], result: ToolResultPart): ModelMessage[];
+/** The messages without the results of the calls in `callIds`, which stay as unanswered calls. */
+export declare function withoutResults(messages: readonly ModelMessage[], callIds: ReadonlySet<string>): ModelMessage[];
+export {};

package/dist/src/harness/session-machine/suspended-steps.js

@@ -0,0 +1 @@
+import{answeredCallIds}from"./view.js";function suspend(e,t){return{...e,suspended:[...e.suspended,t]}}function stepCallIds(e){let t=new Set;for(let n of e.messages)if(n.role===`assistant`&&typeof n.content!=`string`)for(let e of n.content)e.type===`tool-call`&&e.providerExecuted!==!0&&t.add(e.toolCallId);return t}function isComplete(e){let t=answeredCallIds(e.messages);return[...stepCallIds(e)].every(e=>t.has(e))}function withResult(e,t){let n=[...e],r=findCall(n,t.toolCallId);if(r===void 0)return n.push({content:[t],role:`tool`}),n;let i={...t,toolName:r.call.toolName},a=n[r.index+1];return a?.role===`tool`?n[r.index+1]={...a,content:[...a.content,i]}:n.splice(r.index+1,0,{content:[i],role:`tool`}),n}function withoutResults(e,t){return e.flatMap(e=>{if(e.role!==`tool`)return[e];let n=e.content.filter(e=>e.type!==`tool-result`||!t.has(e.toolCallId));return n.length===0?[]:[{...e,content:n}]})}function findCall(e,t){for(let[n,r]of e.entries()){if(r.role!==`assistant`||typeof r.content==`string`)continue;let e=r.content.find(e=>e.type===`tool-call`&&e.toolCallId===t);if(e!==void 0)return{call:e,index:n}}}export{isComplete,stepCallIds,suspend,withResult,withoutResults};

package/dist/src/harness/session-machine/transitions.d.ts

@@ -1,75 +1,74 @@
-import type { ModelMessage, UserContent } from "ai";
-import type { SubagentAuthorizationEventHookPayload, SubagentInputRequestHookPayload } from "#channel/types.js";
+import type { ModelMessage } from "ai";
+import type { SubagentInteractionHookPayload } from "#channel/types.js";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
-import { type TurnWaitingOn, createSessionCompletedEvent, createSessionFailedEvent, type InputResolution, type RuntimeIdentity, type RuntimeTraceContext, type SessionPredecessor, type TaskCancelReason, type TaskStartedStreamEvent, type UnstampedMessageStreamEvent } from "#protocol/message.js";
+import { type InterruptedCall } from "#harness/interrupted-attempt.js";
+import type { RuntimeIdentity, TraceContext, SessionPredecessor } from "#protocol/session-events/families/session.js";
+import type { TaskCancelReason } from "#execution/tasks/table.js";
+import type { DeliverySource, ImportedMessage } from "#protocol/session-events/families/delivery.js";
+import type { ControlDelivery } from "#harness/types.js";
+import type { ResponseSubmittedData } from "#protocol/session-events/families/response.js";
+import type { SessionEvent } from "#protocol/session-event.js";
+import type { Cause, Principal, UserPart } from "#protocol/session-events/envelope.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+import type { FactOf } from "#protocol/session-events/facts.js";
 import type { RuntimeActionResult } from "#shared/action-types.js";
+import type { Answer } from "#shared/input.js";
 import type { JsonObject, JsonValue } from "#shared/json.js";
-import type { SessionHistoryMessage } from "#shared/session-history.js";
-import type { TokenUsage } from "#shared/token-usage.js";
 import type { Transition } from "./commit.js";
-import { type WorkflowAskRoute } from "#harness/hitl/relays.js";
-import type { ApprovedCall, StepCoordinates, SuspendedStep, TurnState } from "./state.js";
+import type { WorkflowAskRoute } from "#harness/hitl/relays.js";
+import type { StoppedCall } from "#harness/inline-tool-authorization.js";
+import type { ApprovedCall, SuspendedStep, TurnState } from "./state.js";
 import { type SessionView } from "./view.js";
-type ToolResponsePart = Extract<ModelMessage, {
-    role: "tool";
-}>["content"][number];
-export type ToolResultPart = Extract<ToolResponsePart, {
-    type: "tool-result";
-}>;
+import { type ToolResultPart } from "./suspended-steps.js";
+/** A delivery a turn consumes, with what the person sent: nothing for an answer or context. */
+export interface ConsumedDelivery {
+    readonly deliveryId: string;
+    readonly parts: readonly UserPart[];
+    /** Earlier conversation the delivery brought, which its consumption records. */
+    readonly history?: readonly ImportedMessage[];
+}
 /**
- * Input arrives: the session starts once, a turn opens unless one is open (steering joins it),
- * any history the delivery added is published, and a message is received.
+ * Deliveries arrive for a turn: the session starts once, a turn opens unless one is open, and
+ * each delivery is consumed into it.
  */
 export declare function receive(view: SessionView, input: {
-    readonly imported?: readonly SessionHistoryMessage[];
-    readonly message?: string | UserContent;
+    readonly deliveries?: readonly ConsumedDelivery[];
+    /** What starts the turn when no delivery does. */
+    readonly cause?: Cause;
+    readonly parent?: {
+        readonly sessionId: string;
+        readonly callId: string;
+    };
     /** The session this one replaced, when eve started it in place of a stranded one. */
     readonly predecessor?: SessionPredecessor;
     readonly runtime?: RuntimeIdentity;
-    readonly trace?: RuntimeTraceContext;
-}): Transition;
-/** The open turn calls the model. */
-export declare function startStep(view: SessionView, input: {
-    readonly modelId: string;
+    readonly trace?: TraceContext;
 }): Transition;
 /**
- * The open turn parks: on `"tasks"` while work it started runs, on `"input"` while a person must
- * act on a sign-in, approval, or question. It resumes in the same turn.
+ * Deliveries join the open turn without opening one, as answers do.
+ * Between turns an answer has nothing to join: it took effect, and settles `applied`. A delivery
+ * already settled, such as one refused, joins nothing.
  */
-export declare function hold(view: SessionView, input: {
-    readonly on: TurnWaitingOn;
-}): Transition;
-/** Nothing is left to run: the turn completes, with its structured result when it has one. */
-export declare function finishTurn(view: SessionView, input?: {
-    readonly result?: JsonValue;
+export declare function join(view: SessionView, input: {
+    readonly deliveries: readonly ConsumedDelivery[];
 }): Transition;
 /**
- * The step failed. A recoverable failure parks the session for the user to retry; a terminal
+ * The step failed. A recoverable failure leaves the session for the user to retry; a terminal
  * one ends it.
  */
 export declare function fail(view: SessionView, failure: {
     readonly code: string;
     readonly details?: JsonObject;
     readonly message: string;
-    readonly terminal?: {
-        readonly sessionId: string;
-    };
+    readonly terminal?: true;
 }): Transition;
-/** The session waits for its next delivery. */
-export declare function idle(view: SessionView): Transition;
-export declare function sessionCompleted(usage: TokenUsage | undefined): ReturnType<typeof createSessionCompletedEvent>;
-export declare function sessionFailed(input: {
-    readonly code: string;
-    readonly details?: JsonObject;
-    readonly message: string;
-    readonly sessionId: string;
-    readonly usage: TokenUsage | undefined;
-}): ReturnType<typeof createSessionFailedEvent>;
 /** One call's result, ready for its step's transcript. */
 export interface SettledCall {
     readonly part: ToolResultPart;
     /** A runtime result, reported at the coordinates of the step that made the call. */
     readonly result?: RuntimeActionResult;
+    /** What the agent behind the call spent, which its settlement records. */
+    readonly usage?: TokenUsage;
 }
 /**
  * Results reach the steps that made their calls. A step whose every call now has a result
@@ -78,26 +77,20 @@ export interface SettledCall {
 export declare function settle(view: SessionView, input: {
     readonly results: readonly SettledCall[];
 }): {
-    commit: ModelMessage[];
-    events: UnstampedMessageStreamEvent[];
-    turn: {
-        queued?: import("../types.ts").StepInput;
-        grants: readonly string[];
-        suspended: SuspendedStep[];
-    };
+    events: SessionEvent[];
+    commit: readonly ModelMessage[];
+    turn: TurnState;
 };
-/** A call a discarded model-call attempt announced without a result. */
-export interface DiscardedCall {
-    readonly callId: string;
-    readonly toolName: string;
-}
 /**
- * A model-call attempt failed and the step retries it. The calls the attempt announced never
- * ran, so each settles as failed before the replacement attempt streams. Nothing reaches
- * history: the discarded response was never committed.
+ * A model-call attempt ends without its response reaching history, in one commit with the calls
+ * it announced. A retry replaces it: eve can't tell whether those calls ran, so they and the run
+ * settle `abandoned`. Steering cut it off: the calls are interrupted, and the run completed what
+ * it streamed, with what it spent.
  */
 export declare function discardAttempt(view: SessionView, input: {
-    readonly calls: readonly DiscardedCall[];
+    readonly runId: string;
+    readonly ending: "retried" | "steered";
+    readonly usage?: FactOf<"usage.recorded">["data"]["usage"];
 }): Transition;
 /**
  * A model response made calls the runtime runs. The response waits in a suspended step until
@@ -107,22 +100,21 @@ export declare function suspendStep(view: SessionView, step: Pick<SuspendedStep,
 /** The step without the approved calls in `callIds`, which have run or joined the runtime. */
 export declare function withoutApproved(step: SuspendedStep, callIds: ReadonlySet<string>): SuspendedStep;
 /**
- * The approved calls of `step` that can run. A call a sign-in stopped is approved too, but waits
- * until every sign-in it stopped on has called back.
+ * The calls of `step` a sign-in stopped that can run: every sign-in each stopped on has called
+ * back.
  */
 export declare function runnableCalls(view: SessionView, step: SuspendedStep): readonly ApprovedCall[];
-/** Approved calls of suspended steps that can run and haven't. */
-export declare function approvedCalls(view: SessionView): readonly ApprovedCall[];
-export declare function suspend(turn: TurnState, step: SuspendedStep): TurnState;
-/** The ids of the calls a step's response made, except provider-executed ones. */
-export declare function stepCallIds(step: Pick<SuspendedStep, "messages">): ReadonlySet<string>;
-/**
- * Places a result right after the message that made its call, under the call's name: a call
- * made through `eve__tool` or `eve__skill` keeps that name in history, whatever entry it ran.
- */
-export declare function withResult(messages: readonly ModelMessage[], result: ToolResultPart): ModelMessage[];
-/** A call started or reached a task. */
-export declare function startTask(view: SessionView, task: TaskStartedStreamEvent["data"]): Transition;
+/** Private dispatch metadata for a call that starts or reaches a task. */
+export interface TaskCallStart {
+    readonly clearedBy?: import("#protocol/session-events/families/call.js").ClearedBy;
+    readonly callId: string;
+    readonly taskId: string;
+    readonly turnId: string;
+    readonly kind: "agent" | "tool";
+    readonly name: string;
+}
+/** A task starts once; every call it serves starts against that task. */
+export declare function startTask(view: SessionView, task: TaskCallStart, introducedTasks?: Set<string>): Transition;
 export type TaskCallOutcome = {
     readonly status: "completed";
     readonly output?: JsonValue;
@@ -135,17 +127,16 @@ export type TaskCallOutcome = {
 };
 /** A task's run settled calls: each reports its outcome, naming the task as it started. */
 export declare function settleTask(view: SessionView, input: {
-    readonly task: {
-        readonly id: string;
-        readonly kind?: TaskStartedStreamEvent["data"]["kind"];
-        readonly name?: string;
-    };
     readonly calls: readonly {
         readonly callId: string;
-        readonly turnId: string;
     }[];
     readonly outcome: TaskCallOutcome;
 }): Transition;
+/** A task's body ended. Replying only settles calls; it never ends a resumable task. */
+export declare function endTask(view: SessionView, input: {
+    readonly taskId: string;
+    readonly outcome: TaskCallOutcome;
+}): Transition;
 /**
  * A task or workflow run ended, on its own or cancelled: nobody can answer what it relayed, so
  * each request still open is withdrawn.
@@ -155,46 +146,50 @@ export declare function finishRun(view: SessionView, run: {
     readonly requestIds?: Iterable<string>;
 }): Transition;
 /**
- * A child session or workflow run asks a question or for a sign-in. The session passes it up
- * with its original coordinates, and the open turn waits on the call it serves.
- * A child's fresh batch replaces its earlier one, whose open requests are withdrawn.
+ * A child session or workflow run relays one of its interaction facts. The session mirrors each
+ * as its own interaction, about the call it serves, with the asker as its origin: a request
+ * opens, and records where its answers go; the asker's settlement closes it; and the asker's
+ * admission or refusal of an answer this session forwarded applies to the forwarded copy. The
+ * open turn waits on a request about one of its calls; a task's request waits on the task.
  */
 export declare function relay(view: SessionView, input: {
-    readonly payload: SubagentInputRequestHookPayload | SubagentAuthorizationEventHookPayload;
-    readonly replacedRequestIds?: Iterable<string>;
+    readonly payload: SubagentInteractionHookPayload;
     /** The workflow tool run that relays the request, and the hook its `ctx.ask()` answers reach. */
     readonly runId?: string;
     readonly workflowAsk?: WorkflowAskRoute;
 }): Transition;
 /**
- * Answers to relayed requests are on their way to the asker: each request resolves here.
+ * Answers to requests this session relays went on to their askers. Each delivery that carried
+ * such answers is admitted here, with the answers it forwarded. An answer joins the open turn
+ * that asked; a delivery that also carries input for this session goes on to its turn. Between
+ * turns, forwarding alone applies the delivery. A question this session decides settles now; an
+ * approval stays open until its asker settles it.
  */
-export declare function receiveRelayedAnswer(input: {
-    readonly message: string | UserContent;
-    readonly sequence: number;
-    readonly turnId: string;
-}): import("#protocol/message.js").MessageReceivedStreamEvent;
 export declare function routeAnswer(view: SessionView, input: {
-    readonly children: readonly {
-        readonly event: StepCoordinates;
-        readonly resolutions: readonly InputResolution[];
+    readonly deliveries: readonly {
+        readonly deliveryId: string;
+        readonly principal?: Principal;
+        readonly source?: DeliverySource;
+        /** The open asking turn consumes the answer, with any message parts it carried. */
+        readonly consumed?: {
+            readonly turnId: string;
+            readonly parts: readonly UserPart[];
+        };
+        /** The delivery also carries input for this session, whose turn consumes and settles it. */
+        readonly continues?: true;
     }[];
+    /** Every answer forwarded, as admitted. */
+    readonly forwarded: readonly ResponseSubmittedData[];
     /**
-     * Answers left other relayed requests pending, and nothing for the turn itself: the open
-     * turn stays held, as after a partial approval answer.
+     * Relayed requests this session settles as it forwards their answer, because nobody else
+     * will before it acts: a workflow run's `ctx.ask()` question, since a run publishes nothing of
+     * its own, and a child's budget prompt this session stops on, since Stop ends its own turn.
      */
-    readonly holds?: boolean;
+    readonly decided: readonly {
+        readonly answer: Answer;
+        readonly outcome: "accepted" | "declined";
+    }[];
 }): Transition;
-/**
- * A workflow run's sign-in, reported to the session that owns the run, which relays it. Built
- * where the run asks, at the coordinates of the call it serves.
- */
-export declare function runSignIn(from: {
-    readonly sequence: number;
-    readonly stepIndex: number;
-    readonly taskId?: string;
-    readonly turnId: string;
-}, challenge: AuthorizationChallenge, outcome?: "authorized" | "failed"): import("#protocol/message.js").AuthorizationCompletedStreamEvent | import("#protocol/message.js").AuthorizationRequiredStreamEvent;
 /**
  * Sign-in callbacks matched the attempts `attemptIds` name: the session stops waiting on them.
  * A call they stopped runs once every sign-in it waits on has called back (`runnableCalls`); any
@@ -206,22 +201,40 @@ export declare function matchSignIns(view: SessionView, input: {
 /** The sign-ins calls stopped on, which the calls report when they settle. */
 export declare function callSignIns(turn: TurnState): readonly AuthorizationChallenge[];
 /**
- * The `stopped` calls wait for a sign-in: their results leave the step, and they stay approved,
- * to run once the sign-ins call back, rather than the model asking for them again.
+ * The `stopped` calls wait for a sign-in: their results leave the step, and they stay approved and
+ * open, to run once the sign-ins call back, rather than the model asking for them again.
  */
 export declare function awaitSignIns(step: SuspendedStep, input: {
-    readonly stopped: readonly {
-        readonly action: ApprovedCall["action"];
-        readonly connections: readonly string[];
-    }[];
+    readonly stopped: readonly StoppedCall[];
     readonly challenges: readonly AuthorizationChallenge[];
 }): SuspendedStep;
-/** Sign-in callbacks arrived: each completion is reported at the coordinates of the turn that asked. */
+/**
+ * A call a sign-in stopped settled: the sign-ins it waited on end with it, accepted if it returned
+ * and failed with the reason it didn't. A failure with `retryable: false` is terminal, recorded as
+ * the settlement's `response.retryable`. Published before the call's own settlement.
+ */
+export declare function callSignInsSettled(view: Pick<SessionView, "projection">, call: ApprovedCall, failure?: {
+    readonly reason?: string;
+    readonly retryable?: boolean;
+}): SessionEvent[];
+/**
+ * Sign-in callbacks arrived: each attempt the session still waits on is accepted. A sign-in a
+ * call stopped on settles with the call instead (`callSignInsSettled`).
+ */
 export declare function completeSignIn(view: SessionView, input: {
     readonly completions: readonly AuthorizationChallenge[];
 }): Transition;
-/** Requests this session asked itself and still awaits; relayed requests answer elsewhere. */
-export declare function ownOpenRequestIds(view: Omit<SessionView, "turn">): ReadonlySet<string>;
+/**
+ * The delivery a clear or compact arrived as. One that names none, from a caller that predates
+ * control ids, is named by the position it applies at.
+ */
+export declare function controlDeliveryFor(view: SessionView, given?: ControlDelivery): ControlDelivery;
+/**
+ * A control's transition as a delivery: admitted before what it changes and applied after, in
+ * the same commit, with what it changes naming it as the cause. A control that names no
+ * delivery changes the session on its own.
+ */
+export declare function controlled(delivery: ControlDelivery | undefined, control: string, build: (cause: Cause | undefined) => Transition): Transition;
 /** What the model reads for a call its turn's cancellation stopped before the call settled. */
 export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this call finished.";
 /**
@@ -230,13 +243,24 @@ export declare const CANCELLED_CALL_RESULT = "The turn was cancelled before this
  * calls are stopped. The steps it ran commit to history, each unfinished call answered as
  * cancelled, so the model sees that the work started and stopped.
  */
-export declare function cancel(view: SessionView): Transition;
+export declare function cancel(view: SessionView, input?: {
+    readonly cause?: Cause;
+}): Transition;
+/**
+ * A step was interrupted after it published, and its retry runs from the checkpoint before it.
+ * Each step waiting on what the interrupted attempt did, an answer it applied or a call it
+ * started, can't resume from it again: the step stops, each call it made answered with what the
+ * stream says of it, so none runs again. The events the attempt wrote already say what changed.
+ */
+export declare function stopInterruptedSteps(view: SessionView, input: {
+    readonly calls: ReadonlyMap<string, InterruptedCall>;
+    readonly settledInteractions: ReadonlySet<string>;
+}): Transition;
 /**
  * `session.clear()`: everything the cleared history asked for is withdrawn, its approvals and
  * the session-limit prompt and every sign-in, and the calls awaiting them stop. Requests relayed
  * from live tasks stay: clearing doesn't stop the work that asked them.
  */
-export declare function clear(view: SessionView, input: {
-    readonly sessionId: string;
+export declare function clear(view: SessionView, input?: {
+    readonly cause?: Cause;
 }): Transition;
-export {};

package/dist/src/harness/session-machine/transitions.js

@@ -1 +1 @@
-import{activeTurnId,answeredCallIds,nextStepIndex,runningTasks,turnPosition}from"./view.js";import{inputWithdrawn,signInWithdrawn}from"./events.js";import{openInputs,openSignIns,turnCoordinates}from"#protocol/session-projection.js";import{createActionResultEvent,createAuthorizationCompletedEvent,createAuthorizationRequiredEvent,createContextClearedEvent,createHistoryImportedEvent,createInputRequestedEvent,createInputResolvedEvent,createMessageReceivedEvent,createResultCompletedEvent,createSessionCompletedEvent,createSessionFailedEvent,createSessionStartedEvent,createSessionWaitingEvent,createStepFailedEvent,createStepStartedEvent,createTaskSettledEvent,createTaskStartedEvent,createTurnCancelledEvent,createTurnCompletedEvent,createTurnFailedEvent,createTurnStartedEvent,createTurnWaitingEvent}from"#protocol/message.js";import{toProxyInputRequestEntries}from"#harness/hitl/relays.js";import{authorizationEventFields}from"#harness/authorization-event-fields.js";import{signInAttemptKey}from"#harness/hitl/sign-ins.js";const unchanged=(e,t)=>({events:t,turn:e.turn});function at(e){let t=turnPosition(e);return{sequence:t.sequence,stepIndex:t.stepIndex,turnId:activeTurnId(t)}}function receive(e,t){let n=turnPosition(e.projection),r=activeTurnId(n),i=[];return n.sessionStarted||i.push(createSessionStartedEvent({predecessor:t.predecessor,runtime:t.runtime,trace:t.trace})),n.turnId===``&&i.push(createTurnStartedEvent({sequence:n.sequence,trace:t.trace,turnId:r})),t.imported!==void 0&&t.imported.length>0&&i.push(createHistoryImportedEvent({messages:t.imported,sequence:n.sequence,turnId:r})),t.message!==void 0&&i.push(createMessageReceivedEvent({message:t.message,sequence:n.sequence,turnId:r})),unchanged(e,i)}function startStep(e,t){let{sequence:n,turnId:r}=at(e.projection);return unchanged(e,[createStepStartedEvent({modelId:t.modelId,sequence:n,stepIndex:nextStepIndex(e.projection),turnId:r})])}function hold(e,t){let{sequence:n,turnId:r}=turnPosition(e.projection);return r===``?unchanged(e,[]):unchanged(e,[createTurnWaitingEvent({on:t.on,sequence:n,turnId:r,usage:e.usage})])}function finishTurn(e,t={}){let{sequence:n,stepIndex:r,turnId:i}=at(e.projection),a=[];return t.result!==void 0&&a.push(createResultCompletedEvent({result:t.result,sequence:n,stepIndex:r,turnId:i})),e.projection.activeTurnId!==void 0&&a.push(createTurnCompletedEvent({sequence:n,turnId:i})),a.push(createSessionWaitingEvent(e.usage)),unchanged(e,a)}function fail(e,t){let{sequence:n,stepIndex:r,turnId:i}=at(e.projection),a=e.turn.suspended.filter(e=>(e.approved?.length??0)>0);return{commit:a.flatMap(cancelledTranscript),events:failedEvents(e,t,{sequence:n,stepIndex:r,turnId:i}),turn:{...e.turn,suspended:e.turn.suspended.filter(e=>!a.includes(e))}}}function failedEvents(e,t,n){let{sequence:r,stepIndex:i,turnId:a}=n,{code:o,details:s,message:c}=t,l=t.terminal!==void 0;return[createStepFailedEvent({code:o,details:s,message:c,sequence:r,stepIndex:i,turnId:a}),createTurnFailedEvent({code:o,details:s,message:c,sequence:r,terminal:l,turnId:a}),t.terminal===void 0?createSessionWaitingEvent(e.usage):createSessionFailedEvent({code:o,details:s,message:c,sessionId:t.terminal.sessionId,usage:e.usage})]}function idle(e){return unchanged(e,[createSessionWaitingEvent(e.usage)])}function sessionCompleted(e){return createSessionCompletedEvent(e)}function sessionFailed(e){return createSessionFailedEvent(e)}function settle(e,t){let n=[],r=[...e.turn.suspended];for(let{part:e,result:i}of t.results){let t=r.findIndex(t=>stepCallIds(t).has(e.toolCallId)),a=r[t];a!==void 0&&(r[t]=withoutApproved({...a,messages:withResult(a.messages,e)},new Set([e.toolCallId])),i!==void 0&&n.push(createActionResultEvent({result:i,...a.event})))}for(let t of r)t.tasks.length!==0&&t.requests.length!==0&&(runningTasks(t).length>0||t.requests.some(t=>t.requestId in e.projection.inputs)||n.push(createInputRequestedEvent({requests:t.requests,...t.event})));let i=r.filter(isComplete);return{commit:i.flatMap(e=>e.messages),events:n,turn:{...e.turn,suspended:r.filter(e=>!i.includes(e))}}}const RETRIED_CALL_RESULT={code:`MODEL_CALL_ATTEMPT_RETRIED`,message:`The model call attempt was retried before this tool could run.`};function discardAttempt(e,t){let n=at(e.projection);return unchanged(e,t.calls.map(({callId:e,toolName:t})=>createActionResultEvent({...n,result:{callId:e,isError:!0,kind:`tool-result`,output:{...RETRIED_CALL_RESULT},toolName:t}})))}function suspendStep(e,t){return{events:[],turn:suspend(e.turn,{...t,requests:[]})}}function withoutApproved(e,t){if(e.approved===void 0)return e;let n=e.approved.filter(e=>!t.has(e.action.callId));if(n.length===e.approved.length)return e;let{approved:r,...i}=e;return n.length===0?i:{...i,approved:n}}function runnableCalls(e,t){let n=new Set(e.signIns.map(signInAttemptKey));return(t.approved??[]).filter(e=>(e.signIns??[]).every(e=>!n.has(signInAttemptKey(e))))}function approvedCalls(e){return e.turn.suspended.flatMap(t=>runnableCalls(e,t))}function suspend(e,t){return{...e,suspended:[...e.suspended,t]}}function stepCallIds(e){let t=new Set;for(let n of e.messages)if(n.role===`assistant`&&typeof n.content!=`string`)for(let e of n.content)e.type===`tool-call`&&e.providerExecuted!==!0&&t.add(e.toolCallId);return t}function isComplete(e){if(e.requests.length>0)return!1;let t=answeredCallIds(e.messages);return[...stepCallIds(e)].every(e=>t.has(e))}function withResult(e,t){let n=[...e],r=findCall(n,t.toolCallId);if(r===void 0)return n.push({content:[t],role:`tool`}),n;let i={...t,toolName:r.call.toolName},a=n[r.index+1];return a?.role===`tool`?n[r.index+1]={...a,content:[...a.content,i]}:n.splice(r.index+1,0,{content:[i],role:`tool`}),n}function withoutResults(e,t){return e.flatMap(e=>{if(e.role!==`tool`)return[e];let n=e.content.filter(e=>e.type!==`tool-result`||!t.has(e.toolCallId));return n.length===0?[]:[{...e,content:n}]})}function findCall(e,t){for(let[n,r]of e.entries()){if(r.role!==`assistant`||typeof r.content==`string`)continue;let e=r.content.find(e=>e.type===`tool-call`&&e.toolCallId===t);if(e!==void 0)return{call:e,index:n}}}function startTask(e,t){return unchanged(e,[createTaskStartedEvent(t)])}function settleTask(e,t){let{outcome:n,task:r}=t;return unchanged(e,t.calls.map(e=>{let t={callId:e.callId,kind:r.kind,name:r.name,taskId:r.id,turnId:e.turnId};switch(n.status){case`completed`:return createTaskSettledEvent({...t,output:n.output,status:`completed`});case`failed`:return createTaskSettledEvent({...t,error:{message:n.error},status:`failed`});case`cancelled`:return createTaskSettledEvent(n.reason===void 0?{...t,status:`cancelled`}:{...t,cancel:{reason:n.reason},status:`cancelled`})}}))}function finishRun(e,t){let n=new Set(t.requestIds);return unchanged(e,openInputs(e.projection).filter(e=>n.has(e.request.requestId)||t.taskId!==void 0&&e.taskId===t.taskId).map(inputWithdrawn))}function relay(e,t){let{payload:n}=t,r=[...finishRun(e,{requestIds:t.replacedRequestIds}).events];if(n.kind===`subagent-input-request`){let{event:e}=n;r.push(createInputRequestedEvent({callId:n.callId,requests:e.requests,sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId}))}else{let{event:t}=n;if(r.push(t),t.type!==`authorization.required`)return unchanged(e,r)}if(r.push(...hold(e,{on:`input`}).events),n.kind!==`subagent-input-request`)return unchanged(e,r);let i=toProxyInputRequestEntries(n).map(([e,n])=>[e,{...n,...t.workflowAsk!==void 0&&{workflowAsk:t.workflowAsk},...t.runId!==void 0&&{runId:t.runId}}]);return{...unchanged(e,r),relays:{upsert:{entries:i,forChildContinuationToken:n.childContinuationToken,inputSource:n.inputSource}}}}function receiveRelayedAnswer(e){return createMessageReceivedEvent(e)}function routeAnswer(e,t){let n=t.children.filter(e=>e.resolutions.length>0).map(e=>createInputResolvedEvent({resolutions:e.resolutions,...e.event}));t.holds===!0&&n.push(...hold(e,{on:`input`}).events);let r=t.children.flatMap(e=>e.resolutions.map(e=>e.requestId));return{...unchanged(e,n),...r.length>0&&{relays:{retire:r}}}}function runSignIn(e,t,n){let r={...authorizationEventFields(t),sequence:e.sequence,stepIndex:e.stepIndex,taskId:e.taskId,turnId:e.turnId};return n===void 0?createAuthorizationRequiredEvent({...r,description:`Sign in to ${t.name} to continue.`,webhookUrl:t.hookUrl}):createAuthorizationCompletedEvent({...r,outcome:n})}function matchSignIns(e,t){let n=new Set(t.attemptIds);return{...unchanged(e,[]),signIns:e.signIns.filter(e=>!n.has(signInAttemptKey(e)))}}function callSignIns(e){return e.suspended.flatMap(e=>(e.approved??[]).flatMap(e=>e.signIns??[]))}function awaitSignIns(e,t){let n=stepCallIds(e),r=t.stopped.filter(({action:e})=>n.has(e.callId));if(r.length===0)return e;let i=r.map(({action:n,connections:r})=>{let i=e.approved?.find(e=>e.action.callId===n.callId);return{action:n,requestId:i?.requestId??n.callId,signIns:[...i?.signIns??[],...t.challenges.filter(e=>r.includes(e.name))]}}),a=new Set(i.map(e=>e.action.callId));return{...e,messages:withoutResults(e.messages,a),approved:[...(e.approved??[]).filter(e=>!a.has(e.action.callId)),...i]}}function completeSignIn(e,t){let n=at(e.projection),r=new Set(callSignIns(e.turn).map(signInAttemptKey));return unchanged(e,t.completions.filter(e=>!r.has(signInAttemptKey(e))).map(t=>{let r=t.attemptId===void 0?void 0:e.projection.authorizations[t.attemptId];return createAuthorizationCompletedEvent({...authorizationEventFields(t),outcome:`authorized`,sequence:r?.sequence??n.sequence,stepIndex:r?.stepIndex??n.stepIndex,turnId:r?.turnId??n.turnId})}))}function ownOpenRequestIds(e){return new Set(openInputs(e.projection).filter(t=>t.callId===void 0&&t.taskId===void 0&&!e.relayedRequestIds.has(t.request.requestId)).map(e=>e.request.requestId))}const CANCELLED_CALL_RESULT=`The turn was cancelled before this call finished.`;function cancel(e){let{projection:t}=e,n=t.activeTurnId,r=e.turn.suspended.filter(e=>n!==void 0&&e.event.turnId===n||e.tasks.some(t=>!answeredCallIds(e.messages).has(t.callId))||(e.approved?.length??0)>0),i=new Set(r.flatMap(e=>e.requests.map(e=>e.requestId))),a=[...openInputs(t).filter(t=>t.turnId===n||i.has(t.request.requestId)||e.relayedRequestIds.has(t.request.requestId)||t.request.kind===`session-limit`).map(inputWithdrawn),...openSignIns(t).filter(e=>e.turnId===n).map(e=>signInWithdrawn(e,`Cancelled.`))];if(n!==void 0){let{sequence:e}=turnCoordinates(t);a.push(createTurnCancelledEvent({sequence:e,turnId:n}))}return a.push(createSessionWaitingEvent(e.usage)),{commit:r.flatMap(cancelledTranscript),events:a,signIns:[],turn:{...e.turn,suspended:e.turn.suspended.filter(e=>!r.includes(e))}}}function cancelledTranscript(e){let t=answeredCallIds(e.messages),n=[...e.messages];for(let r of e.messages)if(r.role===`assistant`&&typeof r.content!=`string`)for(let e of r.content)e.type===`tool-call`&&e.providerExecuted!==!0&&(t.has(e.toolCallId)||(n=withResult(n,{output:{type:`text`,value:CANCELLED_CALL_RESULT},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`})));return n}function clear(e,t){let{projection:n}=e,{sequence:r,turnId:i}=turnCoordinates(n);return{clearsHistory:!0,events:[...openInputs(n).filter(t=>!e.relayedRequestIds.has(t.request.requestId)).map(inputWithdrawn),...openSignIns(n).map(e=>signInWithdrawn(e,`The context was cleared.`)),createContextClearedEvent({sequence:r,sessionId:t.sessionId,turnId:i}),createSessionWaitingEvent(e.usage)],turn:{grants:e.turn.grants,suspended:[]}}}export{CANCELLED_CALL_RESULT,approvedCalls,awaitSignIns,callSignIns,cancel,clear,completeSignIn,discardAttempt,fail,finishRun,finishTurn,hold,idle,matchSignIns,ownOpenRequestIds,receive,receiveRelayedAnswer,relay,routeAnswer,runSignIn,runnableCalls,sessionCompleted,sessionFailed,settle,settleTask,startStep,startTask,stepCallIds,suspend,suspendStep,withResult,withoutApproved};
+import{activeTurnId,answeredCallIds,turnPosition}from"./view.js";import{isComplete,stepCallIds,suspend,withResult,withoutResults}from"./suspended-steps.js";import{activeTurn,interactionOwner}from"#protocol/session-projection/selectors.js";import{isOpen}from"#protocol/session-projection/tree.js";import{callSettledFrom}from"#harness/call-facts.js";import{contextStarted,controlAdmitted,defined,delegatedUsageFact,deliveryApplied,errorInfoOf,fact,runSettledFacts,sessionEndedFacts,turnSettled}from"#harness/facts.js";import{activeTurnIdOf,nextChangeId,openRunOf}from"#protocol/session-projection.js";import{closeUnder}from"#harness/session-machine/cascade.js";import{interruptedCallResult}from"#harness/interrupted-attempt.js";import{interactionSettled,responseAdmitted,responseSettled,responseSubmitted,signInInteractionId}from"#harness/interaction-facts.js";import{signInAttemptKey}from"#harness/hitl/sign-ins.js";const unchanged=(e,t)=>({events:t,turn:e.turn});function followedTurn(e){let t=e.view.selection;return t===null?null:t?.turnId??e.view.session.latestTurnId??null}function waitingDeliveries(e,t){return t.filter(({deliveryId:t})=>e.view?.deliveries[t]?.status===`admitted`)}function consumed(e,t){return fact(`delivery.consumed`,{deliveryId:e.deliveryId,history:(e.history?.length??0)>0?e.history:void 0,parts:e.parts,turnId:t})}function receive(e,t){let{projection:n}=e,r=turnPosition(n),i=activeTurnId(r),a=waitingDeliveries(n,t.deliveries??[]),o=a[0],s=o===void 0?t.cause??{policy:`system`}:{deliveryId:o.deliveryId},{parent:c,predecessor:l,runtime:u,trace:d}=t,f=[];return r.sessionStarted||f.push(fact(`session.started`,{parent:c,predecessor:l,runtime:u,trace:d})),r.turnId===``&&f.push(fact(`turn.started`,{cause:s,follows:followedTurn(n),trace:d,turnId:i})),f.push(...a.map(e=>consumed(e,i))),unchanged(e,f)}function join(e,t){let{projection:n}=e,r=waitingDeliveries(n,t.deliveries),i=activeTurnIdOf(n);return unchanged(e,i===void 0?r.map(({deliveryId:e})=>deliveryApplied(e)):r.map(e=>consumed(e,i)))}function fail(e,t){let n=e.turn.suspended.filter(e=>(e.approved?.length??0)>0),r=errorInfoOf(t),i=activeTurnIdOf(e.projection),a=i===void 0?void 0:openRunOf(e.projection,i),o=[...a===void 0?[]:runSettledFacts({runId:a,outcome:`failed`,error:r}),...t.terminal===void 0?turnSettled(e.projection,{error:r,outcome:`failed`}):sessionEndedFacts(e.projection,{cause:i===void 0?void 0:{turnId:i},error:r,outcome:`failed`})];return{...commitSteps(e.turn,n,cancelledTranscript),events:o}}function settle(e,t){let n=[],r=[...e.turn.suspended];for(let{part:i,result:a,usage:o}of t.results){let t=r.findIndex(e=>stepCallIds(e).has(i.toolCallId)),s=r[t];if(s===void 0)continue;r[t]=withoutApproved({...s,messages:withResult(s.messages,i)},new Set([i.toolCallId]));let c=a===void 0?void 0:e.projection.view.calls[a.callId];a!==void 0&&c!==void 0&&c.taskId===void 0&&c.status!==`settled`&&(n.push(callSettledFrom(a)),o!==void 0&&n.push(delegatedUsageFact(a.callId,o)))}let i=r.filter(isComplete);return{...commitSteps({...e.turn,suspended:r},i),events:n}}function discardAttempt(e,t){let n=e.projection.view,r={family:`run`,id:t.runId},i=t.ending===`steered`?closeUnder(n,r,`steered`):[];if(!isOpen(n,r))return unchanged(e,i);let a=t.ending===`retried`?{outcome:`abandoned`,runId:t.runId,usage:t.usage}:{finishReason:`other`,outcome:`completed`,runId:t.runId,usage:t.usage};return unchanged(e,[...i,...runSettledFacts(a)])}function suspendStep(e,t){return{events:[],turn:suspend(e.turn,{...t,requests:[]})}}function withoutApproved(e,t){if(e.approved===void 0)return e;let n=e.approved.filter(e=>!t.has(e.call.callId));if(n.length===e.approved.length)return e;let{approved:r,...i}=e;return n.length===0?i:{...i,approved:n}}function runnableCalls(e,t){let n=new Set(e.signIns.map(signInAttemptKey));return(t.approved??[]).filter(e=>(e.signIns??[]).every(e=>!n.has(signInAttemptKey(e))))}function startTask(e,t,n){let r=[];return(n?.has(t.taskId)??e.projection.view.tasks[t.taskId]!==void 0)||(n?.add(t.taskId),r.push({type:`task.started`,data:{taskId:t.taskId,kind:t.kind,name:t.name,startedBy:{callId:t.callId}}})),r.push({type:`call.started`,data:defined({callId:t.callId,taskId:t.taskId,clearedBy:t.clearedBy})}),unchanged(e,r)}function settleTask(e,t){let{outcome:n}=t,r=n.status===`completed`?n.output:void 0,i=t.calls[0]?.callId,a=t.calls.map(({callId:e},t)=>fact(`call.settled`,{callId:e,error:n.status===`failed`?{code:`TASK_FAILED`,message:n.error}:void 0,outcome:n.status===`cancelled`?`interrupted`:n.status,output:t===0?r:void 0,outputOf:t>0&&r!==void 0&&i!==void 0?{callId:i}:void 0,reason:n.status===`cancelled`?n.reason??`task-cancelled`:void 0}));return unchanged(e,a)}function endTask(e,t){let n=e.projection.view.tasks[t.taskId];if(n===void 0||n.status===`ended`)return unchanged(e,[]);let{outcome:r}=t;return unchanged(e,[fact(`task.ended`,{error:r.status===`failed`?{code:`TASK_FAILED`,message:r.error}:void 0,outcome:r.status,reason:r.status===`cancelled`?r.reason??`task-ended`:void 0,taskId:t.taskId})])}function finishRun(e,t){let n=new Set(t.requestIds),r=e.projection.view,i=Object.values(r.interactions).filter(e=>e.status===`open`&&(n.has(e.interactionId)||t.taskId!==void 0&&interactionOwner(r,e).taskId===t.taskId));return unchanged(e,i.map(e=>withdrawInteraction(e.interactionId,`asker-ended`)))}function withdrawInteraction(e,t,n=`withdrawn`){return interactionSettled(e,n,{reason:t})}function relay(e,t){let{payload:n}=t,r=e.projection.view,i=n.route===void 0?void 0:{...n.route,...t.workflowAsk!==void 0&&{workflowAsk:t.workflowAsk},...t.runId!==void 0&&{runId:t.runId}},a=[],o={};for(let e of n.events){let t=e.data.interactionId,s=r.interactions[t];if(e.type===`interaction.opened`||s?.origin!==void 0&&`callId`in s.subject&&s.subject.callId===n.callId)switch(e.type){case`interaction.opened`:if(s!==void 0)break;a.push({data:{...e.data,origin:e.data.origin??{interactionId:t,sessionId:n.childSessionId},subject:{callId:n.callId}},type:`interaction.opened`}),i!==void 0&&e.data.request.kind!==`sign-in`&&(o[t]=i);break;case`interaction.settled`:if(s?.status!==`open`)break;a.push(...mirrorSettled(r,e.data));break;case`response.admitted`:{let t=s===void 0?void 0:forwardedAnswer(r,e.data);t!==void 0&&r.responses[t]?.status===`submitted`&&a.push(responseAdmitted(t));break}case`response.settled`:{let t=s===void 0?void 0:forwardedAnswer(r,e.data);t!==void 0&&e.data.outcome!==`applied`&&a.push(responseSettled(t,e.data.outcome,e.data.reason));break}}}return Object.keys(o).length>0?{...unchanged(e,a),relays:o}:unchanged(e,a)}function mirrorSettled(e,t){let n=Object.values(e.responses).filter(e=>e.interactionId===t.interactionId&&e.status!==`settled`).sort((e,t)=>e.introducedAt-t.introducedAt),r=t.outcome===`accepted`||t.outcome===`declined`||t.outcome===`invalid`?n.at(-1):void 0,i=r===void 0?[]:[responseSettled(r.responseId,`applied`,t.reason)],a=r===void 0?t.cause:{responseId:r.responseId};return i.push(fact(`interaction.settled`,{...t,cause:a})),i}function forwardedAnswer(e,t){let n=Object.values(e.responses).filter(e=>e.interactionId===t.interactionId&&e.status!==`settled`).sort((e,t)=>e.introducedAt-t.introducedAt);return(n.find(e=>t.deliveryId!==void 0&&e.deliveryId===t.deliveryId)??n.at(-1))?.responseId}function routeAnswer(e,t){let n=e.projection.view,r=[],i=new Set;for(let e of t.deliveries){if(n.deliveries[e.deliveryId]!==void 0||i.has(e.deliveryId))continue;i.add(e.deliveryId);let{deliveryId:t,principal:a,source:o}=e;r.push(fact(`delivery.admitted`,{deliveryId:t,principal:a,source:o})),e.consumed!==void 0&&r.push(consumed({deliveryId:t,parts:e.consumed.parts},e.consumed.turnId))}let known=e=>i.has(e)||n.deliveries[e]!==void 0,a=new Map;for(let e of t.forwarded)n.responses[e.responseId]===void 0&&n.interactions[e.interactionId]?.status===`open`&&known(e.deliveryId)&&(a.set(e.responseId,e),r.push(responseSubmitted(e)));for(let{answer:e,outcome:i}of t.decided){let t=n.interactions[e.interactionId];if(t?.status!==`open`)continue;let o=[...Object.values(n.responses).filter(e=>e.interactionId===t.interactionId&&e.status!==`settled`).map(e=>e.responseId),...[...a.values()].filter(e=>e.interactionId===t.interactionId).map(e=>e.responseId)].at(-1);o!==void 0&&r.push(responseSettled(o,`applied`)),r.push(interactionSettled(t.interactionId,i,{cause:o===void 0?void 0:{responseId:o},response:e}))}for(let e of t.deliveries)e.consumed===void 0&&e.continues!==!0&&i.has(e.deliveryId)&&r.push(deliveryApplied(e.deliveryId));return unchanged(e,r)}function matchSignIns(e,t){let n=new Set(t.attemptIds);return{...unchanged(e,[]),signIns:e.signIns.filter(e=>!n.has(signInAttemptKey(e)))}}function callSignIns(e){return e.suspended.flatMap(e=>(e.approved??[]).flatMap(e=>e.signIns??[]))}function awaitSignIns(e,t){let n=stepCallIds(e),r=t.stopped.filter(({call:e})=>n.has(e.callId));if(r.length===0)return e;let i=r.map(({approval:n,call:r,connections:i})=>{let a=e.approved?.find(e=>e.call.callId===r.callId),o=n?.interactionId??a?.interactionId,s=n?.responder??a?.responder;return{call:r,...o!==void 0&&{interactionId:o},...s!==void 0&&{responder:s},signIns:[...a?.signIns??[],...t.challenges.filter(e=>i.includes(e.name))]}}),a=new Set(i.map(e=>e.call.callId));return{...e,messages:withoutResults(e.messages,a),approved:[...(e.approved??[]).filter(e=>!a.has(e.call.callId)),...i]}}function signInCallbackFacts(e,t,n){let r=signInInteractionId(t);if(e.interactions[r]?.status!==`open`)return[];let i=`callback_${r}`,a=`response_${i}`,o=interactionSettled(r,n.outcome,{cause:{responseId:a},...n.reason!==void 0&&{reason:n.reason}});return[{data:{deliveryId:i,source:{callback:`authorization`}},type:`delivery.admitted`},responseSubmitted({deliveryId:i,interactionId:r,responseId:a}),responseSettled(a,`applied`),n.retryable===!1?{...o,data:{...o.data,response:{retryable:!1}}}:o,deliveryApplied(i)]}function callSignInsSettled(e,t,n){let r=e.projection.view,i=n===void 0?{outcome:`accepted`}:{...n,outcome:`failed`};return(t.signIns??[]).flatMap(e=>signInCallbackFacts(r,e,i))}function completeSignIn(e,t){let n=e.projection.view,r=new Set(callSignIns(e.turn).map(signInAttemptKey));return unchanged(e,t.completions.filter(e=>!r.has(signInAttemptKey(e))).flatMap(e=>signInCallbackFacts(n,e,{outcome:`accepted`})))}function controlDeliveryFor(e,t){return t??{deliveryId:`control_${String(e.projection.view.position)}`}}function controlled(e,t,n){if(e===void 0)return n(void 0);let r=n({deliveryId:e.deliveryId});return{...r,events:[controlAdmitted(e,t),...r.events,deliveryApplied(e.deliveryId)]}}const CANCELLED_CALL_RESULT=`The turn was cancelled before this call finished.`;function cancel(e,t={}){let{projection:n}=e,r=activeTurnIdOf(n),i=e.turn.suspended.filter(e=>r!==void 0&&e.event.turnId===r||e.tasks.some(t=>!answeredCallIds(e.messages).has(t.callId))||(e.approved?.length??0)>0),a=new Set(i.flatMap(e=>e.requests.map(e=>e.interactionId))),o=n.view,s=Object.values(o.interactions).filter(t=>t.status===`open`&&(e.relayedRequestIds.has(t.interactionId)||a.has(t.interactionId)||t.request.kind===`budget`)).map(e=>withdrawInteraction(e.interactionId,`Cancelled.`,`interrupted`));s.push(...turnSettled(n,{cause:t.cause,outcome:`cancelled`},activeTurn(o)?.turnId??r),...unreadSettled(e));let{queued:c,...l}=e.turn;return{...commitSteps(l,i,cancelledTranscript),events:s,signIns:[]}}function unreadSettled(e){let t=e.projection.view;return(e.turn.queued?.deliveries??[]).filter(({deliveryId:e})=>t.deliveries[e]?.status===`admitted`).map(({deliveryId:e})=>fact(`delivery.settled`,{deliveryId:e,outcome:`ignored`}))}function cancelledTranscript(e){return stoppedTranscript(e,()=>CANCELLED_CALL_RESULT)}function stopInterruptedSteps(e,t){let n=e.turn.suspended.filter(e=>e.requests.some(e=>t.settledInteractions.has(e.interactionId))||[...stepCallIds(e)].some(e=>t.calls.get(e)?.started===!0));return{...commitSteps(e.turn,n,e=>stoppedTranscript(e,e=>interruptedCallResult(t.calls.get(e)))),events:[]}}function commitSteps(e,t,n=e=>e.messages){let r=new Set(t);return{commit:t.flatMap(n),turn:{...e,suspended:e.suspended.filter(e=>!r.has(e))}}}function stoppedTranscript(e,t){let n=answeredCallIds(e.messages),r=[...e.messages];for(let i of e.messages)if(i.role===`assistant`&&typeof i.content!=`string`)for(let e of i.content)e.type===`tool-call`&&e.providerExecuted!==!0&&(n.has(e.toolCallId)||(r=withResult(r,{output:{type:`text`,value:t(e.toolCallId)},toolCallId:e.toolCallId,toolName:e.toolName,type:`tool-result`})));return r}function clear(e,t={}){let{projection:n}=e,r=nextChangeId(n);return{clearsHistory:!0,signIns:[],events:[...clearedInteractions(e),...turnSettled(n,{cause:t.cause,outcome:`cancelled`}),...unreadSettled(e),contextStarted({cause:t.cause,changeId:r,kind:`clear`}),fact(`context.settled`,{changeId:r,kind:`clear`,outcome:`completed`,selects:null})],turn:{remembered:e.turn.remembered,suspended:[]}}}function clearedInteractions(e){let t=e.projection.view;return Object.values(t.interactions).filter(t=>t.status===`open`&&!e.relayedRequestIds.has(t.interactionId)).map(e=>withdrawInteraction(e.interactionId,`The context was cleared.`,`interrupted`))}export{CANCELLED_CALL_RESULT,awaitSignIns,callSignIns,callSignInsSettled,cancel,clear,completeSignIn,controlDeliveryFor,controlled,discardAttempt,endTask,fail,finishRun,join,matchSignIns,receive,relay,routeAnswer,runnableCalls,settle,settleTask,startTask,stopInterruptedSteps,suspendStep,withoutApproved};

package/dist/src/harness/session-machine/view.d.ts

@@ -1,12 +1,12 @@
-import type { TokenUsage } from "#shared/token-usage.js";
 import type { ModelMessage } from "ai";
 import type { AuthorizationChallenge } from "#harness/authorization.js";
+import type { PendingResponder } from "#harness/hitl/index.js";
 import { type TaskToolCall } from "#execution/tasks/calls.js";
-import type { SessionStateMap, StepInput } from "#harness/types.js";
+import type { SessionStateMap, HarnessStepInput } from "#harness/types.js";
 import type { RuntimeWorkflowTaskRequest } from "#shared/action-types.js";
 import { type SessionProjection } from "#protocol/session-projection.js";
 import { type StepCoordinates, type SuspendedStep, type TurnState } from "./state.js";
-export type { StepCoordinates, SuspendedStep, TurnState } from "./state.js";
+export type { ApprovalAsk, ApprovedCall, StepCoordinates, SuspendedStep, TurnState, } from "./state.js";
 export declare const SESSION_PROJECTION_STATE_KEY = "eve.harness.sessionProjection";
 /** What a transition sees. */
 export interface SessionView {
@@ -14,10 +14,10 @@ export interface SessionView {
     readonly projection: SessionProjection;
     /** Requests this session relays for a child session or a workflow run, by `requestId`. */
     readonly relayedRequestIds: ReadonlySet<string>;
+    /** Who gave each answer a response policy still weighs, by response id. */
+    readonly responders: Readonly<Record<string, PendingResponder>>;
     /** The sign-in attempts the session waits on, with what completing them needs. */
     readonly signIns: readonly AuthorizationChallenge[];
-    /** The session's token usage so far, which its waiting and terminal events report. */
-    readonly usage: TokenUsage;
 }
 /** Reads the authoritative lifecycle facts saved alongside execution state. */
 export declare function storedProjection(state: SessionStateMap | undefined): SessionProjection;
@@ -30,15 +30,15 @@ export interface TurnPosition {
     readonly turnId: string;
     /** The open turn streamed assistant output, so steering can no longer restart it. */
     readonly assistantOutputStarted?: boolean;
+    /** The open turn's latest open model run, which content and calls belong to. */
+    readonly runId?: string;
 }
 export declare function turnPosition(projection: SessionProjection): TurnPosition;
 /** The open turn's id, or the id the next turn takes. */
 export declare function activeTurnId(position: Pick<TurnPosition, "sequence" | "turnId">): string;
 export declare function isBetweenTurns(projection: SessionProjection): boolean;
-/** The index the open turn's next `step.started` takes. */
-export declare function nextStepIndex(projection: SessionProjection): number;
 /** Input the session holds until it can run. */
-export declare function queuedInput(state: SessionStateMap | undefined): StepInput | undefined;
+export declare function queuedInput(state: SessionStateMap | undefined): HarnessStepInput | undefined;
 export declare function suspendedSteps(state: SessionStateMap | undefined): readonly SuspendedStep[];
 /** The ids of calls that already have a result in `messages`. */
 export declare function answeredCallIds(messages: readonly ModelMessage[]): ReadonlySet<string>;
@@ -53,3 +53,7 @@ export interface RuntimeWait {
 }
 /** The calls suspended steps wait on the runtime for, or `undefined` when none do. */
 export declare function runtimeWait(state: SessionStateMap | undefined): RuntimeWait | undefined;
+/** The suspended step whose approval `interactionId` names. */
+export declare function stepForRequest(view: SessionView, interactionId: string): SuspendedStep | undefined;
+/** Requests this session asked itself and still awaits; relayed requests answer elsewhere. */
+export declare function ownOpenRequestIds(view: Omit<SessionView, "turn">): ReadonlySet<string>;