eve 0.55.0 → 0.57.0

package/dist/src/execution/session/handoff.d.ts

@@ -0,0 +1,69 @@
+import type { SessionCapabilities } from "#channel/types.js";
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import type { SessionInboxHandle, SessionInboxPayload } from "#execution/session-inbox/inbox.js";
+import type { TurnSelection } from "#execution/session/input-queue.js";
+import type { WorkflowEntryResult } from "#execution/session/entry-input.js";
+import type { AgentWorkflowRetentionDefinition } from "#shared/agent-definition.js";
+import type { RunMode } from "#shared/run-mode.js";
+/**
+ * Cross-deployment checkpoint contract. The successor may run a different eve
+ * build than the owner that produced it; bump when any field changes shape so
+ * an incompatible successor rejects the handoff instead of misreading state.
+ */
+export declare const SESSION_CHECKPOINT_VERSION = 4;
+/** Everything a successor needs to continue an idle session. Hooks are derived from the state. */
+export interface SessionCheckpoint {
+    readonly version: typeof SESSION_CHECKPOINT_VERSION;
+    readonly capabilities?: SessionCapabilities;
+    readonly mode: RunMode;
+    readonly retention?: AgentWorkflowRetentionDefinition;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+    readonly sessionTimeoutMs: number | false;
+}
+export type SessionOwnerActivation = {
+    readonly kind: "active";
+} | {
+    readonly kind: "failed";
+    readonly error: unknown;
+    /** Commands accepted by partial successor claims before startup failed. */
+    readonly payloads: readonly SessionInboxPayload[];
+};
+export type SessionTransferOutcome = {
+    readonly kind: "transferred";
+} | {
+    readonly kind: "retained";
+    readonly reason: "same-deployment" | "missing-deployment" | "not-idle" | "busy" | "accepted-during-release" | "activation-failed";
+};
+export interface SessionHandoffInput {
+    readonly checkpoint: Omit<SessionCheckpoint, "serializedContext" | "sessionState" | "version">;
+    readonly deploymentId: string;
+    readonly inbox: SessionInboxHandle;
+    readonly isInitialOwner: boolean;
+    readonly sessionId: string;
+}
+export declare function sessionAnchorToken(sessionId: string): string;
+/**
+ * The sole boundary for moving an idle session to another exact deployment.
+ * Constructed once per owner; `tryTransfer()` is attempted per eligible selection.
+ * When the upstream atomic hook-handoff primitive lands, only this class changes.
+ */
+export declare class SessionHandoff {
+    private readonly input;
+    private anchor;
+    constructor(input: SessionHandoffInput);
+    /**
+     * Attempts to move the session to the selected delivery's deployment. The
+     * outcome states whether the successor activated or this owner retained the
+     * session. Candidate failures recover locally rather than escaping.
+     */
+    tryTransfer(selection: TurnSelection, state: Pick<SessionCheckpoint, "serializedContext" | "sessionState">): Promise<SessionTransferOutcome>;
+    /** After a transfer, the original run parks until the final owner reports the session result. */
+    awaitAnchoredResult(): Promise<WorkflowEntryResult>;
+    disposeAnchor(): Promise<void>;
+    /** Starts the candidate and waits for it to activate or fail. */
+    private startAndActivate;
+    /** Reclaims the exact hook set and replays payloads accepted while it was released. */
+    private recover;
+    private ensureAnchor;
+}

package/dist/src/execution/session/handoff.js

@@ -0,0 +1 @@
+import{sessionHandoffMarkerToken}from"#execution/session-inbox/address.js";import{startSessionOwnerStep}from"#execution/workflow-runtime.js";import{createHook,getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{claimHookOwnership,disposeHook}from"#execution/hook-ownership.js";import{sessionHookTokens}from"#execution/session/hook-tokens.js";import{isSessionIdleForHandoffStep}from"#execution/session/handoff-steps.js";import{readAcceptedDeploymentId}from"#execution/session/accepted-deployment.js";const SESSION_CHECKPOINT_VERSION=4;function sessionAnchorToken(e){return`${e}:anchor`}var SessionHandoff=class{input;anchor;constructor(e){this.input=e}async tryTransfer(e,t){let{deploymentId:n,inbox:r}=this.input,i=readAcceptedDeploymentId(e.delivery);if(i===void 0)return{kind:`retained`,reason:`missing-deployment`};if(i===n)return{kind:`retained`,reason:`same-deployment`};if(!e.handoffEligible)return{kind:`retained`,reason:`busy`};if(!await isSessionIdleForHandoffStep(t))return{kind:`retained`,reason:`not-idle`};let a={...this.input.checkpoint,...t,version:4},o=sessionHookTokens(t);await this.ensureAnchor();let s=o.map(e=>createHook({token:sessionHandoffMarkerToken(e)}));await Promise.all(s.map(e=>claimHookOwnership(e)));try{let t=await r.release();if(t.length>0)return await this.recover(o,t),{kind:`retained`,reason:`accepted-during-release`};let n=[];try{let t=await this.startAndActivate(a,e.delivery,i);if(t.kind===`active`)return{kind:`transferred`};n=t.payloads}catch{}return await this.recover(o,n),{kind:`retained`,reason:`activation-failed`}}finally{await Promise.all(s.map(e=>disposeHook(e)))}}async awaitAnchoredResult(){if(this.anchor===void 0)throw Error(`Session anchor was never claimed.`);try{return await this.anchor}finally{await this.disposeAnchor()}}async disposeAnchor(){if(this.anchor===void 0)return;let e=this.anchor;this.anchor=void 0,await disposeHook(e)}async startAndActivate(e,t,n){let r=createHook({token:`${getWorkflowMetadata().workflowRunId}:handoff`});await claimHookOwnership(r);try{return await startSessionOwnerStep({activationToken:r.token,anchorRunId:this.input.sessionId,checkpoint:e,delivery:t,targetDeploymentId:n}),await r}finally{await disposeHook(r)}}async recover(e,t){await this.input.inbox.claimSessionHooks(e),this.input.inbox.restore(t)}async ensureAnchor(){this.input.isInitialOwner&&this.anchor===void 0&&(this.anchor=createHook({token:sessionAnchorToken(this.input.sessionId)}),await claimHookOwnership(this.anchor))}};export{SESSION_CHECKPOINT_VERSION,SessionHandoff,sessionAnchorToken};

package/dist/src/execution/session/hook-tokens.d.ts

@@ -0,0 +1,11 @@
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+/**
+ * Every hook a session answers to, derived from its committed state: the
+ * stable command inbox plus each continuation alias a channel handler
+ * selected. This is the one source of truth for claims at boot, at every
+ * state transition, and across a deployment handoff.
+ */
+export declare function sessionHookTokens(input: {
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: Pick<DurableSessionState, "continuationToken" | "sessionId">;
+}): readonly string[];

package/dist/src/execution/session/hook-tokens.js

@@ -0,0 +1 @@
+import{sessionCommandHookToken}from"#execution/session-inbox/address.js";import{ContinuationHookTokensKey}from"#context/keys.js";function sessionHookTokens(e){let t=e.serializedContext[ContinuationHookTokensKey.name],n=new Set([sessionCommandHookToken(e.sessionState.sessionId)]);if(Array.isArray(t))for(let e of t)typeof e==`string`&&e.length>0&&n.add(e);return e.sessionState.continuationToken!==``&&n.add(e.sessionState.continuationToken),[...n]}export{sessionHookTokens};

package/dist/src/execution/session/input-queue.d.ts

@@ -0,0 +1,72 @@
+import type { DeliverHookPayload, DeliverPayload } from "#channel/types.js";
+import type { getSessionTaskCohorts } from "#tasks/session-task-cohorts.js";
+export type SessionControl = "clear" | "compact" | "expired" | "reset";
+type TaskCohorts = ReturnType<typeof getSessionTaskCohorts>;
+export interface DeliveryAdmission {
+    readonly delivery: DeliverHookPayload;
+    readonly sequence: number;
+}
+export interface TurnSelection {
+    readonly delivery: DeliverHookPayload;
+    /**
+     * True only for a lone, callerless conversational delivery that arrived
+     * while nothing else was pending. Such a delivery may move the session to
+     * the deployment that accepted it.
+     */
+    readonly handoffEligible: boolean;
+    readonly kind: "turn";
+    /** Sequences of every admission folded into this turn. */
+    readonly sequences: readonly number[];
+}
+export type SessionInputSelection = TurnSelection | {
+    readonly control: SessionControl;
+    readonly kind: "control";
+} | {
+    readonly kind: "authorization-resume";
+    readonly payloads: readonly DeliverPayload[];
+};
+/**
+ * Ordered, admitted session input, plus the idempotency and cancellation
+ * facts for task deliveries this owner has seen. Entries are private; callers
+ * receive typed admission and selection values. Everything here is rebuilt
+ * deterministically on replay, and a successor never inherits it because
+ * handoff requires every indexed task to be terminal.
+ */
+export declare class SessionInputQueue {
+    private readonly entries;
+    private readonly cancelledTaskIds;
+    private readonly seenTaskDeliveryIds;
+    private nextSequence;
+    get pendingCount(): number;
+    /** Admits a delivery unless it repeats or belongs to a cancelled task. */
+    enqueueDelivery(delivery: DeliverHookPayload): DeliveryAdmission | undefined;
+    /** A caller's own task id counts as seen so its echo is not admitted twice. */
+    rememberTask(taskId: string): void;
+    isTaskCancelled(taskId: string): boolean;
+    enqueueControl(control: SessionControl): void;
+    /** Keeps one payload per authorization attempt; a repeated callback for the same attempt is dropped. */
+    enqueueAuthorization(payloads: readonly DeliverPayload[]): void;
+    delivery(sequence: number): DeliverHookPayload | undefined;
+    replaceDelivery(sequence: number, delivery: DeliverHookPayload | undefined): void;
+    /** Drops queued notifications from a cancelled task and refuses later ones. */
+    cancelTask(taskId: string): void;
+    takeSteering(admitted: ReadonlySet<number>, callerCallId: string | undefined): TurnSelection | undefined;
+    takeNext(cohorts: TaskCohorts, options?: {
+        readonly deferDeliveries?: boolean;
+        /**
+         * Attempt ids of the open authorization challenge. Callbacks for other
+         * attempts are stale and dropped; once every expected attempt has
+         * reported, the collected payloads resume the challenge ahead of
+         * ordinary input.
+         */
+        readonly expectedAttemptIds?: ReadonlySet<string>;
+        /** Sequence of a delivery admitted while nothing else was pending. */
+        readonly freshSequence?: number;
+    }): SessionInputSelection | undefined;
+    private nextActionableIndex;
+    private takeSelectionAt;
+    private isCancelledTaskDelivery;
+    private retain;
+}
+export declare function isSteeringDelivery(delivery: DeliverHookPayload, callerCallId: string | undefined): boolean;
+export {};

package/dist/src/execution/session/input-queue.js

@@ -0,0 +1 @@
+import{jsonValuesEqual}from"#shared/json.js";import{coalesceDeliveries}from"#harness/messages.js";var SessionInputQueue=class{entries=[];cancelledTaskIds=new Set;seenTaskDeliveryIds=new Set;nextSequence=0;get pendingCount(){return this.entries.length}enqueueDelivery(e){let t=taskDeliveryId(e);if(t!==void 0){if(this.seenTaskDeliveryIds.has(t)||this.isCancelledTaskDelivery(t))return;this.seenTaskDeliveryIds.add(t)}let n={delivery:e,sequence:this.nextSequence++};return this.entries.push({...n,kind:`delivery`}),n}rememberTask(e){this.seenTaskDeliveryIds.add(e)}isTaskCancelled(e){return this.cancelledTaskIds.has(e)}enqueueControl(e){this.entries.push({control:e,kind:`control`,sequence:this.nextSequence++})}enqueueAuthorization(e){for(let t of e){let e=authorizationAttemptId(t);e!==void 0&&(this.entries.some(t=>t.kind===`authorization`&&t.attemptId===e)||this.entries.push({attemptId:e,kind:`authorization`,payload:t,sequence:this.nextSequence++}))}}delivery(e){return this.entries.find(t=>t.kind===`delivery`&&t.sequence===e)?.delivery}replaceDelivery(e,t){let n=this.entries.findIndex(t=>t.kind===`delivery`&&t.sequence===e);if(!(n<0)){if(t===void 0){this.entries.splice(n,1);return}this.entries[n]={delivery:t,kind:`delivery`,sequence:e}}}cancelTask(e){this.cancelledTaskIds.add(e),this.retain(t=>t.kind!==`delivery`||!isTaskDelivery(t.delivery,t=>t===e||t.startsWith(`${e}:`)))}takeSteering(e,t){let n=this.entries.filter(n=>n.kind===`delivery`&&e.has(n.sequence)&&isSteeringDelivery(n.delivery,t));if(n.length!==0)return this.retain(e=>e.kind!==`delivery`||!n.includes(e)),{delivery:combine(n),handoffEligible:!1,kind:`turn`,sequences:n.map(({sequence:e})=>e)}}takeNext(e,t){let n=t?.expectedAttemptIds??new Set;if(this.retain(e=>e.kind!==`authorization`||n.has(e.attemptId)),n.size>0){let e=new Map(this.entries.flatMap(e=>e.kind===`authorization`?[[e.attemptId,e.payload]]:[]));if([...n].every(t=>e.has(t)))return this.retain(e=>e.kind!==`authorization`),{kind:`authorization-resume`,payloads:[...n].map(t=>e.get(t))}}let r=this.nextActionableIndex(e,t?.deferDeliveries===!0);if(!(r<0))return this.takeSelectionAt(r,e,t?.freshSequence)}nextActionableIndex(e,t){let n=this.entries.filter(e=>e.kind===`delivery`),r=new Set(n.flatMap(({delivery:e})=>{let t=completionTaskId(e);return t===void 0?[]:[t]})),i=new Set;for(let[t,n]of e)!n.settled&&!r.has(t)&&!this.cancelledTaskIds.has(t)&&i.add(n.cohortId);return this.entries.findIndex(n=>{if(n.kind===`control`)return!0;if(n.kind===`authorization`||t)return!1;let r=completionCohort(n.delivery,e);return r===void 0||!i.has(r)})}takeSelectionAt(e,t,n){let r=this.entries[e];if(r.kind!==`delivery`)return this.entries.splice(e,1),r.kind===`control`?{control:r.control,kind:`control`}:{kind:`authorization-resume`,payloads:[r.payload]};let i=completionCohort(r.delivery,t);if(i!==void 0){let r=this.entries.findLastIndex(e=>e.kind===`delivery`&&completionCohort(e.delivery,t)===i),a=this.entries.findIndex((n,i)=>i>e&&i<r&&(n.kind!==`delivery`||completionCohort(n.delivery,t)===void 0));if(a>=0)return this.takeSelectionAt(a,t,n)}let a=this.entries.splice(e,1)[0];if(a.kind!==`delivery`)throw Error(`Selected a non-delivery entry as a turn.`);let o=[a],s=completionCohort(a.delivery,t);if(s!==void 0){let e=this.entries.filter(e=>e.kind===`delivery`&&completionCohort(e.delivery,t)===s);o.push(...e),this.retain(e=>e.kind!==`delivery`||completionCohort(e.delivery,t)!==s)}else{let t=a.delivery.auth!=null&&a.delivery.auth.principalType!==`anonymous`,n=a.delivery.caller;for(;this.entries.length>e;){let r=this.entries[e];if(r?.kind!==`delivery`||a.delivery.taskDeliveryId!==void 0||r.delivery.taskDeliveryId!==void 0||!t||!jsonValuesEqual(a.delivery.auth,r.delivery.auth)||n!==void 0&&r.delivery.caller!==void 0)break;o.push(this.entries.splice(e,1)[0]),n??=r.delivery.caller}}let c=o.map(({sequence:e})=>e),l=combine(o);return{delivery:l,handoffEligible:c.length===1&&c[0]===n&&l.caller===void 0&&taskDeliveryId(l)===void 0&&this.entries.length===0,kind:`turn`,sequences:c}}isCancelledTaskDelivery(e){for(let t of this.cancelledTaskIds)if(e===t||e.startsWith(`${t}:`))return!0;return!1}retain(e){let t=this.entries.filter(e);this.entries.splice(0,this.entries.length,...t)}};function isSteeringDelivery(e,t){return e.taskDeliveryId===void 0&&(e.turnPolicy??`steer`)===`steer`&&(e.caller===void 0||e.caller.callId===t)}function combine(e){return e.length===1?e[0].delivery:coalesceDeliveries(e.map(({delivery:e})=>e))}function authorizationAttemptId(e){let t=e.authorizationCallback;return typeof t?.attemptId==`string`?t.attemptId:void 0}function taskDeliveryId(e){return e.taskDeliveryId??e.caller?.taskId}function isTaskDelivery(e,t){let n=taskDeliveryId(e);return n!==void 0&&t(n)}function completionCohort(e,t){let n=completionTaskId(e);return n===void 0?void 0:t.get(n)?.cohortId}function completionTaskId(e){if(e.caller===void 0&&e.taskDeliveryId?.endsWith(`:ready:completed`))return e.taskDeliveryId.slice(0,-16)}export{SessionInputQueue,isSteeringDelivery};

package/dist/src/execution/session/next-input.d.ts

@@ -0,0 +1,32 @@
+import type { DeliverPayload } from "#channel/types.js";
+import type { SessionControl, SessionInputQueue, TurnSelection } from "#execution/session/input-queue.js";
+import type { SessionInboxReader } from "#execution/session-inbox/inbox.js";
+import type { SessionStateCursor } from "#execution/session/state-cursor.js";
+import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
+export type NextTurnInstruction = {
+    readonly kind: "workflow";
+    readonly message: WorkflowToolRunMessage;
+} | {
+    readonly kind: "authorization-resume";
+    readonly payloads: readonly DeliverPayload[];
+} | {
+    readonly kind: SessionControl;
+} | {
+    readonly kind: "closed";
+} | {
+    readonly kind: "cancel-turn";
+} | TurnSelection;
+/**
+ * Waits for the next input the parked owner must act on. While an
+ * authorization challenge is open, its callbacks collect in the queue and
+ * resume the challenge once every expected attempt has reported; ordinary
+ * deliveries keep starting turns in the meantime. Fully routed descendant
+ * deliveries leave nothing for the parent, so the wait continues.
+ */
+export declare function nextTurnDelivery(input: {
+    readonly inbox: SessionInboxReader;
+    readonly cursor: SessionStateCursor;
+    readonly deferDeliveries?: boolean;
+    readonly expectedAttemptIds?: ReadonlySet<string>;
+    readonly queue: SessionInputQueue;
+}): Promise<NextTurnInstruction>;

package/dist/src/execution/session/next-input.js

@@ -0,0 +1 @@
+import{routeSelectedDelivery}from"#execution/session/route-selected-delivery.js";import{admitSessionInboxPayload,applySessionCancellation}from"#execution/session/admission.js";import{getSessionTaskCohorts}from"#tasks/session-task-cohorts.js";async function nextTurnDelivery(e){let{inbox:t,cursor:n,queue:r}=e,i;for(;;){let a=r.takeNext(getSessionTaskCohorts(n.sessionState.snapshot.session.state),{deferDeliveries:e.deferDeliveries,expectedAttemptIds:e.expectedAttemptIds,freshSequence:t.hasPending()?void 0:i});if(a?.kind===`control`)return{kind:a.control};if(a?.kind===`authorization-resume`)return a;if(a?.kind===`turn`){let e=await routeSelectedDelivery(a,n);if(e.kind===`cancel-turn`)return e;if(e.kind===`consumed`)continue;return e}let o=r.pendingCount===0,s=await t.next();if(s===void 0)return{kind:`closed`};let c=await admitSessionInboxPayload(s,e);switch(i=o&&c.kind===`delivery`?c.admission.sequence:void 0,c.kind){case`workflow`:return{kind:`workflow`,message:c.message};case`cancel`:await applySessionCancellation(c.command,e)}}}export{nextTurnDelivery};

package/dist/src/execution/{pending-turn-state.d.ts → session/pending-turn-state.d.ts}

@@ -2,7 +2,6 @@ import type { HarnessSession } from "#harness/types.js";
 /** Derives the workflow fields used to select the next action at the park boundary. */
 export declare function derivePendingState(session: HarnessSession): {
     readonly authorizationAttemptIds?: readonly string[];
-    readonly authorizationNames?: readonly string[];
     readonly hasPendingAuthorization: boolean;
     readonly hasPendingInputBatch: boolean;
     readonly pendingCoordinationCallIds?: readonly string[];

package/dist/src/execution/{pending-turn-state.js → session/pending-turn-state.js}

@@ -1 +1 @@
-import{getPendingCoordinationBatch}from"#harness/coordination.js";import{getPendingAuthorization}from"#harness/authorization.js";import{hasPendingInputBatch}from"#harness/input-requests.js";function derivePendingState(e){let t=getPendingCoordinationBatch(e.state),n=getPendingAuthorization(e.state),r={authorizationAttemptIds:n?.challenges.flatMap(e=>e.attemptId===void 0?[]:[e.attemptId]),authorizationNames:n?.challenges.map(e=>e.name),hasPendingAuthorization:n!==void 0,hasPendingInputBatch:hasPendingInputBatch(e.state)};return t===void 0?r:{...r,pendingCoordinationCallIds:[...t.runtimeActions,...t.tasks].map(e=>e.callId)}}export{derivePendingState};
+import{getPendingCoordinationBatch}from"#harness/coordination.js";import{getPendingAuthorization}from"#harness/authorization.js";import{hasPendingInputBatch}from"#harness/input-requests.js";function derivePendingState(e){let t=getPendingCoordinationBatch(e.state),n=getPendingAuthorization(e.state),r={authorizationAttemptIds:n?.challenges.flatMap(e=>e.attemptId===void 0?[]:[e.attemptId]),hasPendingAuthorization:n!==void 0,hasPendingInputBatch:hasPendingInputBatch(e.state)};return t===void 0?r:{...r,pendingCoordinationCallIds:[...t.runtimeActions,...t.tasks].map(e=>e.callId)}}export{derivePendingState};

package/dist/src/execution/session/program.d.ts

@@ -0,0 +1,47 @@
+import type { DeliverHookPayload, SessionCapabilities, TurnCaller } from "#channel/types.js";
+import type { AgentWorkflowRetentionDefinition } from "#shared/agent-definition.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import { type SessionInboxHandle } from "#execution/session-inbox/inbox.js";
+import type { WorkflowEntryResult } from "#execution/session/entry-input.js";
+/**
+ * Who to tell when this owner exits. The original run anchors the public
+ * stream itself; a successor signals the original run. A `self` anchor may
+ * also name a `notify` step that runs with the final result, which lets an
+ * importer settle whatever predecessor still holds the stream open.
+ */
+export type SessionAnchor = {
+    readonly kind: "self";
+    readonly notify?: (result: WorkflowEntryResult) => Promise<void>;
+} | {
+    readonly kind: "successor";
+};
+export interface SessionBoot {
+    readonly anchor: SessionAnchor;
+    readonly caller: TurnCaller | undefined;
+    readonly capabilities?: SessionCapabilities;
+    readonly deploymentId: string;
+    readonly initialInput: DeliverHookPayload | undefined;
+    readonly mode: RunMode;
+    readonly retention?: AgentWorkflowRetentionDefinition;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionId: string;
+    readonly sessionState: DurableSessionState;
+    readonly sessionTimeoutDeadline?: Date;
+    readonly sessionTimeoutMs: number | false;
+    readonly sessionWritable: WritableStream<Uint8Array>;
+}
+/** Runs an already prepared owner against its session's existing stream. */
+export declare function runPreparedSession(boot: SessionBoot, inbox: SessionInboxHandle): Promise<WorkflowEntryResult>;
+/**
+ * Terminal path for a boot that failed before the session loop could run.
+ * The caller is re-resolved from context because no turn ever bound it.
+ */
+export declare function failSession(input: {
+    readonly error: unknown;
+    readonly mode: RunMode;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionId: string;
+    readonly sessionState: DurableSessionState | undefined;
+    readonly sessionWritable: WritableStream<Uint8Array>;
+}): Promise<never>;

package/dist/src/execution/session/program.js

@@ -0,0 +1 @@
+import{settleCancelledTurnStep}from"#execution/settle-cancelled-turn-step.js";import"#execution/session-inbox/inbox.js";import{bindTurnCallerContextStep,notifyCancelledTaskCallerStep,notifyTurnCallerStep,resolveInitialTurnCallerStep}from"#subagents/parent-notification.js";import{signalSessionAnchorStep}from"#execution/session/handoff-steps.js";import{SessionHandoff,sessionAnchorToken}from"#execution/session/handoff.js";import{nextTurnDelivery}from"#execution/session/next-input.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{SessionInputQueue}from"#execution/session/input-queue.js";import{SessionExecution}from"#execution/session/turn.js";import{SessionStateCursor}from"#execution/session/state-cursor.js";import{finalizeSession}from"#execution/session/finalization.js";import{createSessionTimeoutControl}from"#execution/session/timeout-control.js";function createSafeOuterWorkflowError(){let e=Error(`Agent workflow failed. Inspect the private session trace for details.`);return e.name=`EveWorkflowFailure`,e}async function runPreparedSession(e,t){let n=new SessionStateCursor({inbox:t,sessionWritable:e.sessionWritable,serializedContext:e.serializedContext,sessionState:e.sessionState}),r={caller:e.caller,terminalEmitted:!1},i=new SessionHandoff({checkpoint:{capabilities:e.capabilities,mode:e.mode,retention:e.retention,sessionTimeoutMs:e.sessionTimeoutMs},deploymentId:e.deploymentId,inbox:t,isInitialOwner:e.anchor.kind===`self`,sessionId:e.sessionId}),a={output:``,isError:!0};try{let o;try{o=await runSessionLoop(e,{cursor:n,handoff:i,inbox:t,progress:r})}finally{await t.dispose()}return o.kind===`transferred`?e.anchor.kind===`self`?(a=await i.awaitAnchoredResult(),a):{output:``}:(a=await finalizeSession(o.outcome,{caller:r.caller,cursor:n,mode:e.mode,sessionWritable:e.sessionWritable}),r.terminalEmitted=!0,a)}catch(t){throw r.terminalEmitted||await finalizeSession({error:t,kind:`failed`,turnId:r.turnId},{caller:r.caller,cursor:n,mode:e.mode,sessionWritable:e.sessionWritable}),createSafeOuterWorkflowError()}finally{await reportResultToAnchor(e,a,i)}}async function failSession(e){let t;try{t=await resolveInitialTurnCallerStep({serializedContext:e.serializedContext})}catch{}throw await finalizeSession({error:e.error,kind:`failed`},{caller:t,cursor:{serializedContext:e.serializedContext,sessionState:e.sessionState},mode:e.mode,sessionWritable:e.sessionWritable}),createSafeOuterWorkflowError()}async function reportResultToAnchor(e,t,n){switch(e.anchor.kind){case`self`:await n.disposeAnchor(),await e.anchor.notify?.(t);return;case`successor`:await signalSessionAnchorStep({result:t,token:sessionAnchorToken(e.sessionId)});return}}async function runSessionLoop(e,t){let{cursor:n,handoff:r,inbox:i,progress:a}=t,o=new SessionInputQueue,s=new SessionExecution({capabilities:e.capabilities,cursor:n,inbox:i,mode:e.mode,queue:o,sessionId:e.sessionId}),c=e.sessionTimeoutDeadline===void 0?void 0:createSessionTimeoutControl({deadline:e.sessionTimeoutDeadline,sessionId:e.sessionId}),nextParkedActivity=async t=>{for(;;){let r=await nextTurnDelivery({cursor:n,deferDeliveries:e.mode===`task`&&t.size>0,expectedAttemptIds:t,inbox:i,queue:o});if(r.kind!==`workflow`)return r;await s.handleWorkflowMessage(r.message)}},l=0,runTurn=async e=>{let t=a.caller;return t?.taskId!==void 0&&o.rememberTask(t.taskId),t!==void 0&&await n.apply({serializedContext:await bindTurnCallerContextStep({caller:t,serializedContext:n.serializedContext})}),a.turnId=`turn_${String(l++)}`,await s.runTurn(e)},settleCancelledTurn=async()=>{let t=await settleCancelledTurnStep({sessionWritable:e.sessionWritable,serializedContext:n.serializedContext,sessionState:n.sessionState});return await n.apply(t),a.caller=void 0,t};try{let[t,i]=await Promise.allSettled([runTurn(e.initialInput===void 0?void 0:{delivery:e.initialInput}),c?.start()]);if(i.status===`rejected`)throw i.reason;if(t.status===`rejected`)throw t.reason;let o=t.value;for(;;){if(o.kind===`done`)return{kind:`terminal`,outcome:{action:o,kind:`done`}};if(o.cancelled===!0){let t={caller:a.caller,sessionId:e.sessionId},n=await settleCancelledTurn();await notifyCancelledTaskCallerStep(n.usage===void 0?t:{...t,usage:n.usage})}else o.settled!==void 0&&(a.caller!==void 0&&await notifyTurnCallerStep({caller:a.caller,lifecycle:`parked`,sessionId:e.sessionId,settled:o.settled}),a.caller=void 0);let t=await nextParkedActivity(new Set(o.authorizationAttemptIds??[]));switch(t.kind){case`authorization-resume`:o=await runTurn({delivery:{kind:`deliver`,payloads:t.payloads}});continue;case`expired`:case`reset`:case`closed`:return{kind:`terminal`,outcome:{kind:`expired`}};case`clear`:case`compact`:o=await runTurn({control:t.kind});continue;case`cancel-turn`:await cancelDescendantTurnsStep({serializedContext:n.serializedContext,sessionState:n.sessionState}),await settleCancelledTurn(),o={...o,settled:void 0};continue;case`turn`:if((await r.tryTransfer(t,{serializedContext:n.serializedContext,sessionState:n.sessionState})).kind===`transferred`)return{kind:`transferred`};t.delivery.caller!==void 0&&(a.caller=t.delivery.caller),o=await runTurn({delivery:t.delivery});continue}}}finally{await c?.dispose()}}export{failSession,runPreparedSession};

package/dist/src/execution/session/route-selected-delivery.d.ts

@@ -0,0 +1,9 @@
+import type { TurnSelection } from "#execution/session/input-queue.js";
+import type { SessionStateCursor } from "#execution/session/state-cursor.js";
+export type RoutedTurnSelection = {
+    readonly kind: "cancel-turn";
+} | {
+    readonly kind: "consumed";
+} | TurnSelection;
+/** Routes one selected delivery exactly once, independent of active/parked mode. */
+export declare function routeSelectedDelivery(selection: TurnSelection, cursor: SessionStateCursor): Promise<RoutedTurnSelection>;

package/dist/src/execution/session/route-selected-delivery.js

@@ -0,0 +1 @@
+import{routeDeliverToChildren}from"#execution/route-child-delivery.js";async function routeSelectedDelivery(e,t){let n=await routeDeliverToChildren({delivery:e.delivery,sessionWritable:t.sessionWritable,serializedContext:t.serializedContext,sessionState:t.sessionState});return await t.apply(n),n.kind===`cancel-turn`?{kind:`cancel-turn`}:n.remainder===void 0?{kind:`consumed`}:{...e,delivery:n.remainder}}export{routeSelectedDelivery};

package/dist/src/execution/session/state-cursor.d.ts

@@ -0,0 +1,31 @@
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import type { SessionInboxOwnership } from "#execution/session-inbox/inbox.js";
+import type { TurnStepInput, TurnStepPayload } from "#execution/session/turn-step-types.js";
+/** A durable-state transition; absent fields keep the cursor's current value. */
+export interface SessionStateTransition {
+    readonly serializedContext?: Record<string, unknown>;
+    readonly sessionState?: DurableSessionState;
+}
+/**
+ * The one mutable serialized-context / session-state pair owned by the
+ * workflow executing a session. Steps return transitions; the cursor adopts
+ * them and claims any continuation address a step introduced, so every hook
+ * the session answers to is registered before the next step runs.
+ */
+export declare class SessionStateCursor {
+    readonly sessionWritable: WritableStream<Uint8Array>;
+    private readonly inbox;
+    private currentSerializedContext;
+    private currentSessionState;
+    constructor(input: {
+        readonly inbox: Pick<SessionInboxOwnership, "claimSessionHooks">;
+        readonly sessionWritable: WritableStream<Uint8Array>;
+        readonly serializedContext: Record<string, unknown>;
+        readonly sessionState: DurableSessionState;
+    });
+    get serializedContext(): Record<string, unknown>;
+    get sessionState(): DurableSessionState;
+    /** Applies a transition after claiming every continuation address it introduced. */
+    apply(transition: SessionStateTransition): Promise<void>;
+    createStepInput(input: TurnStepPayload | undefined, signals: Pick<TurnStepInput, "abortSignal" | "steeringSignal">): TurnStepInput;
+}

package/dist/src/execution/session/state-cursor.js

@@ -0,0 +1 @@
+import{sessionHookTokens}from"#execution/session/hook-tokens.js";var SessionStateCursor=class{sessionWritable;inbox;currentSerializedContext;currentSessionState;constructor(e){this.inbox=e.inbox,this.sessionWritable=e.sessionWritable,this.currentSerializedContext=e.serializedContext,this.currentSessionState=e.sessionState}get serializedContext(){return this.currentSerializedContext}get sessionState(){return this.currentSessionState}async apply(e){let t=e.serializedContext??this.currentSerializedContext,n=e.sessionState??this.currentSessionState;await this.inbox.claimSessionHooks(sessionHookTokens({serializedContext:t,sessionState:n})),this.currentSerializedContext=t,this.currentSessionState=n}createStepInput(e,t){return{...t,input:e,sessionWritable:this.sessionWritable,serializedContext:this.currentSerializedContext,sessionState:this.currentSessionState}}};export{SessionStateCursor};

package/dist/src/execution/{session-timeout-control.d.ts → session/timeout-control.d.ts}

@@ -6,5 +6,5 @@ export interface SessionTimeoutControl {
 /** Creates a timer controller for one stable session command inbox. */
 export declare function createSessionTimeoutControl(input: {
     readonly deadline: Date;
-    readonly token: string;
+    readonly sessionId: string;
 }): SessionTimeoutControl;

package/dist/src/execution/session/timeout-control.js

@@ -0,0 +1 @@
+import{sessionCommandHookToken}from"#execution/session-inbox/address.js";import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{cancelSessionTimeoutStep,startSessionTimeoutStep}from"#execution/session/timeout-steps.js";function createSessionTimeoutControl(e){let t;return{async dispose(){if(t===void 0)return;let e=t;t=void 0,await cancelSessionTimeoutStep({runId:e.runId})},async start(){t===void 0&&(t=await startSessionTimeoutStep({deadline:e.deadline,ownerRunId:getWorkflowMetadata().workflowRunId,token:sessionCommandHookToken(e.sessionId)}))}}}export{createSessionTimeoutControl};

package/dist/src/execution/{session-timeout-steps.d.ts → session/timeout-steps.d.ts}

@@ -1,10 +1,11 @@
-import type { SessionTimeoutWorkflowInput } from "#execution/session-timeout-workflow.js";
+import type { SessionTimeoutWorkflowInput } from "#execution/session/timeout-workflow.js";
 /** Starts the durable timer that signals one session deadline. */
 export declare function startSessionTimeoutStep(input: SessionTimeoutWorkflowInput): Promise<{
     readonly runId: string;
 }>;
-/** Resumes the owning driver when its durable timer elapses. */
+/** Resumes the owning session when its durable timer elapses. */
 export declare function signalSessionTimeoutStep(input: {
+    readonly ownerRunId: string;
     readonly token: string;
 }): Promise<void>;
 /** Cancels a timer whose session reached another terminal outcome first. */

package/dist/src/execution/session/timeout-steps.js

@@ -0,0 +1 @@
+import{walkCauseChain}from"#shared/errors.js";import{sessionTimeoutWorkflowReference,startWorkflowOnCurrentDeployment}from"#execution/workflow-runtime.js";import{cancelRun,getWorld}from"#internal/workflow/runtime.js";import{EntityConflictError,HookNotFoundError,RunExpiredError,WorkflowRunNotFoundError}from"#compiled/@workflow/errors/index.js";import{resumeSessionInbox}from"#execution/session-inbox/resume.js";async function startSessionTimeoutStep(e){"use step";return{runId:(await startWorkflowOnCurrentDeployment(sessionTimeoutWorkflowReference,[e])).runId}}async function signalSessionTimeoutStep(e){"use step";try{await resumeSessionInbox(e.token,{kind:`session-timeout`,ownerRunId:e.ownerRunId})}catch(e){if(!isInactiveTimeoutTarget(e))throw e}}async function cancelSessionTimeoutStep(e){"use step";try{await cancelRun(await getWorld(),e.runId,{cancelReason:`Session ended before its timeout`})}catch(e){if(!isInactiveTimeoutTarget(e))throw e}}function isInactiveTimeoutTarget(e){for(let t of walkCauseChain(e))if(HookNotFoundError.is(t)||WorkflowRunNotFoundError.is(t)||RunExpiredError.is(t)||EntityConflictError.is(t))return!0;return!1}export{cancelSessionTimeoutStep,signalSessionTimeoutStep,startSessionTimeoutStep};

package/dist/src/execution/{session-timeout-workflow.d.ts → session/timeout-workflow.d.ts}

@@ -1,6 +1,8 @@
 export interface SessionTimeoutWorkflowInput {
     readonly deadline: Date;
+    /** Owner run that armed the timer. */
+    readonly ownerRunId: string;
     readonly token: string;
 }
-/** Sleeps until the session deadline, then signals its driver. */
+/** Sleeps until the session deadline, then signals its current owner. */
 export declare function sessionTimeoutWorkflow(input: SessionTimeoutWorkflowInput): Promise<void>;

package/dist/src/execution/session/timeout-workflow.js

@@ -0,0 +1 @@
+import{sleep}from"#compiled/@workflow/core/index.js";import{signalSessionTimeoutStep}from"#execution/session/timeout-steps.js";async function sessionTimeoutWorkflow(e){"use workflow";await sleep(e.deadline),await signalSessionTimeoutStep({ownerRunId:e.ownerRunId,token:e.token})}sessionTimeoutWorkflow.workflowId=`workflow//eve//sessionTimeoutWorkflow`;export{sessionTimeoutWorkflow};

package/dist/src/execution/session/timeout.d.ts

@@ -0,0 +1,3 @@
+/** Default lifetime from creation or the latest successful ownership handoff. */
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+export declare function sessionTimeoutDeadline(timeoutMs: number | false, startedAtMs: number): Date | undefined;

package/dist/src/execution/session/timeout.js

@@ -0,0 +1 @@
+const DEFAULT_SESSION_TIMEOUT_MS=2592e6;function sessionTimeoutDeadline(e,t){return e===!1?void 0:new Date(t+e)}export{DEFAULT_SESSION_TIMEOUT_MS,sessionTimeoutDeadline};

package/dist/src/execution/session/turn-step-result.d.ts

@@ -0,0 +1,4 @@
+import type { DurableStepResult } from "#execution/session/turn-step-types.js";
+import type { StepResult } from "#harness/types.js";
+import type { RunMode } from "#shared/run-mode.js";
+export declare function resolveSessionStepResult(stepResult: StepResult, nextSerializedContext: Record<string, unknown>, mode: RunMode, beforeStepContext: Record<string, unknown>): DurableStepResult;

package/dist/src/execution/session/turn-step-result.js

@@ -0,0 +1 @@
+import{createDurableSessionState}from"#execution/durable-session-store.js";import{preserveSerializedBackgroundTaskObservabilityState}from"#shared/serialized-observability-state.js";import{derivePendingState}from"#execution/session/pending-turn-state.js";import{hasPendingInputBatch}from"#harness/input-requests.js";import{getTurnUsageState,takeSessionUsageDelta,toUsage}from"#harness/turn-tag-state.js";function resolveSessionStepResult(e,t,n,r){let i=createDurableSessionState({session:e.session});if(e.steered)return{action:`steered`,serializedContext:t,sessionState:i};let a=e.backgroundTasks===void 0||e.backgroundTaskSession===void 0?{}:{backgroundTaskContext:preserveSerializedBackgroundTaskObservabilityState(r,t,e.backgroundTasks),backgroundTaskState:createDurableSessionState({session:e.backgroundTaskSession}),backgroundTasks:e.backgroundTasks};if(e.next!==null&&typeof e.next==`object`&&`done`in e.next){if(n===`task`&&hasPendingInputBatch(e.session.state))throw Error(`Task mode cannot complete while input requests remain pending.`);let r=getTurnUsageState(e.session.state)?.session;return{action:`done`,...a,output:e.next.output,isError:e.next.isError,serializedContext:t,sessionState:i,usage:r===void 0?void 0:toUsage(r),usageDelta:takeSessionUsageDelta(e.session).delta}}if(e.next===null){let n=derivePendingState(e.session);if(e.settledTurn!==void 0){let{delta:r,session:i}=takeSessionUsageDelta(e.session);return{action:`park`,...a,...n,serializedContext:t,sessionState:createDurableSessionState({session:i}),settled:{output:e.settledTurn.output,isError:e.settledTurn.isError,usage:r}}}return{action:`park`,...a,...n,serializedContext:t,sessionState:i}}return{action:`continue`,...a,serializedContext:t,sessionState:i}}export{resolveSessionStepResult};

package/dist/src/execution/session/turn-step-types.d.ts

@@ -0,0 +1,68 @@
+import type { DeliverHookPayload } from "#channel/types.js";
+import type { DurableSessionState } from "#execution/durable-session-store.js";
+import type { SettledTurn, StepResult } from "#harness/types.js";
+import type { RuntimeActionResult } from "#shared/action-types.js";
+import type { TokenUsage } from "#shared/token-usage.js";
+/** Trusted runtime-action results collected by the session owner. */
+export interface RuntimeActionResultStepInput {
+    readonly acceptedAtMsByCallId?: Readonly<Record<string, number>>;
+    readonly results: readonly RuntimeActionResult[];
+}
+/**
+ * Everything one turn step may consume. A step can carry a delivery and a
+ * set of runtime results together: steering accepted while a blocking action
+ * was in flight is appended ahead of that action's result in the same step.
+ */
+export interface TurnStepPayload {
+    readonly control?: "clear" | "compact";
+    readonly delivery?: DeliverHookPayload;
+    readonly runtimeResults?: RuntimeActionResultStepInput;
+}
+/** Input for one atomic, session-owner-executed turn step. */
+export interface TurnStepInput {
+    readonly abortSignal?: AbortSignal;
+    readonly steeringSignal?: AbortSignal;
+    readonly input: TurnStepPayload | undefined;
+    readonly sessionWritable: WritableStream<Uint8Array>;
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}
+interface DurableStepResultFields {
+    /** Pre-step context plus the observability state owned by committed background tasks. */
+    readonly backgroundTaskContext?: Record<string, unknown>;
+    readonly backgroundTaskState?: DurableSessionState;
+    readonly backgroundTasks?: StepResult["backgroundTasks"];
+    readonly serializedContext: Record<string, unknown>;
+    readonly sessionState: DurableSessionState;
+}
+/** Result returned by a session-mutating turn step. */
+export type DurableStepResult = ({
+    readonly action: "continue" | "done";
+    readonly output?: unknown;
+    readonly isError?: boolean;
+    readonly usage?: TokenUsage;
+    readonly usageDelta?: TokenUsage;
+} | {
+    readonly action: "cancelled" | "steered";
+} | {
+    readonly action: "park";
+    readonly authorizationAttemptIds?: readonly string[];
+    readonly hasPendingAuthorization: boolean;
+    readonly hasPendingInputBatch: boolean;
+    readonly pendingCoordinationCallIds?: readonly string[];
+    readonly settled?: SettledTurn;
+}) & DurableStepResultFields;
+/** The only two ways a locally executed conversational turn can settle. */
+export type TurnOutcome = {
+    readonly kind: "done";
+    readonly output: unknown;
+    readonly isError?: boolean;
+    readonly usage?: TokenUsage;
+    readonly usageDelta?: TokenUsage;
+} | {
+    readonly authorizationAttemptIds?: readonly string[];
+    readonly cancelled?: true;
+    readonly kind: "park";
+    readonly settled?: SettledTurn;
+};
+export {};

package/dist/src/execution/session/turn-step-types.js

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

package/dist/src/execution/{workflow-steps.d.ts → session/turn-step.d.ts}

@@ -1,5 +1,4 @@
-import type { DurableStepResult } from "#execution/next-driver-action.js";
-import type { TurnStepInput } from "#execution/durable-session-migrations/turn-workflow.js";
+import type { DurableStepResult, TurnStepInput } from "#execution/session/turn-step-types.js";
 export type { TurnStepInput };
 /** Runs a bounded batch of harness model steps inside one durable `"use step"` boundary. */
 export declare function turnStep(rawInput: TurnStepInput): Promise<DurableStepResult>;

package/dist/src/execution/session/turn-step.js

@@ -0,0 +1 @@
+import{defaultDeliverResult}from"#channel/adapter.js";import{contextStorage}from"#context/container.js";import{AuthKey,CapabilitiesKey,ChannelDeliveryKey,HandleEventKey,ModeKey,SessionDynamicSubagentRuntimeRevisionKey,SessionDynamicToolRuntimeRevisionKey,StaticModelReferenceKey,TurnDeliveryIdsKey,TurnTaskDeliveryKey}from"#context/keys.js";import{createAuthorizationCompletedEvent,createSessionStartedEvent,createTurnStartedEvent}from"#protocol/message.js";import{BundleKey,ChannelKey}from"#runtime/sessions/runtime-context-keys.js";import{coalesceTurnInputs}from"#harness/messages.js";import{emitTurnPreamble,getHarnessEmissionState,isHarnessBetweenTurns,setHarnessEmissionState}from"#harness/emission.js";import{createWorkflowRuntime}from"#execution/workflow-runtime.js";import{deserializeContext,serializeContext}from"#context/serialize.js";import{createDurableSessionState,readDurableSession}from"#execution/durable-session-store.js";import{refreshDynamicSessionSubagentsForRuntimeRevision}from"#context/dynamic-subagent-lifecycle.js";import{resolveEffectiveAgentRuntime}from"#execution/effective-agent-config.js";import{hydrateDurableSession,refreshSessionFromTurnAgent}from"#execution/session.js";import{readRetainedBackgroundToolResult,runBackgroundStep}from"#execution/tasks/parent/tool-execution.js";import*as agentTraceState from"#tracing/agent-trace-context-store.js";import{activeTurnId}from"#harness/active-turn-id.js";import{derivePendingState}from"#execution/session/pending-turn-state.js";import{rebindMissingCompiledDynamicToolCallbacks,refreshDynamicSessionToolsForRuntimeRevision}from"#context/dynamic-tool-lifecycle.js";import{setChannelContext}from"#execution/channel-context.js";import{drainDynamicInstructionUserMessages,prepareDynamicInstructionPreamble}from"#context/dynamic-instruction-lifecycle.js";import*as activityCohort from"#execution/activity-cohort.js";import{CallbackBaseUrlKey,PendingAuthorizationResultKey,clearPendingAuthorization,getPendingAuthorization}from"#harness/authorization.js";import{bindSessionInstrumentation}from"#instrumentation/runtime.js";import{RuntimeActionSettlementTimesKey}from"#harness/runtime-action-settlement-state.js";import{matchAuthorizationCallbacks}from"#execution/authorization-callback-match.js";import{isTurnCancellation,throwIfTurnAborted}from"#harness/turn-cancellation.js";import{resolveSessionStepResult}from"#execution/session/turn-step-result.js";import{createSessionEventSink}from"#execution/session/event-sink.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{resolveEffectiveOutputSchema}from"#execution/effective-output-schema.js";import{buildRuntimeIdentity,createExecutionNodeStep}from"#execution/node-step.js";import{getBackgroundTaskDelivery,markBackgroundTaskStepInput,resolveInitiatingTaskContext,resolveTaskDeliveryContext}from"#tasks/delivery-context.js";import{prepareWorkflowPreambleTrace}from"#execution/workflow-trace-context.js";import{reconcileSessionContinuationToken}from"#execution/reconcile-session-continuation-token.js";import{createExecutionHistoryView}from"#execution/history-view.js";import{resolveRuntimeCompiledArtifactsVersionedCacheKey}from"#runtime/cache-key.js";import{runModelCallBatch}from"#execution/model-call-batching.js";import{createCancelledModelCallBatchResult}from"#execution/cancelled-model-call-batch.js";function channelDeliveryErrorCode(e){if(typeof e==`object`&&e&&`code`in e){let t=e.code;if(typeof t==`string`&&t.length>0)return t}return`CHANNEL_DELIVERY_FAILED`}async function turnStep(e){"use step";return runSessionStep(e)}async function runSessionStep(e){let t=e.input?.delivery,n=t,r=e.input?.runtimeResults,i=readDurableSession(e.sessionState),a=await deserializeContext(e.serializedContext),o=a.require(ChannelKey),s=a.require(BundleKey),c=resolveEffectiveAgentRuntime(s,a);try{let{getWorkflowMetadata:e}=await import(`#compiled/@workflow/core/index.js`),t=e();typeof t.url==`string`&&a.set(CallbackBaseUrlKey,resolveWorkflowCallbackBaseUrl(t.url))}catch{}let l=getPendingAuthorization(i.state),u;if(l&&n!==void 0){let{matches:e,remainingPayloads:t}=matchAuthorizationCallbacks(l,n.payloads);if(n={...n,payloads:t},e.length>0){let r=activityCohort.restoreAuthorizationActivity({ctx:a,matches:e,pending:l}),o=e.map(e=>e.result);a.set(PendingAuthorizationResultKey,o),i={...i,state:clearPendingAuthorization(i.state,r)},u=e,t.length===0&&(n=void 0)}}let d=a.get(AuthKey);n?.auth!==void 0&&a.set(AuthKey,n.auth??null);let f=getBackgroundTaskDelivery(n),p=hydrateDurableSession({compactionOverrides:{thresholdPercent:c.thresholdPercent},durable:i,turnAgent:c.turnAgent}),m=createExecutionHistoryView(p),h=bindSessionInstrumentation({agentName:c.turnAgent.id,ctx:a,rootSessionId:p.rootSessionId??p.sessionId,sessionId:p.sessionId}),g=getHarnessEmissionState(p.state);t!==void 0&&await contextStorage.run(a,()=>h?.instrumentChannelDelivery({agentName:s.turnAgent.id,ctx:a,delivery:t,rootSessionId:p.rootSessionId??p.sessionId,sequence:g.sequence,sessionId:p.sessionId,turnId:activeTurnId(g)}));let failChannelDeliveries=async e=>{await contextStorage.run(a,()=>h?.instrumentChannelDelivery({ctx:a,error:e,errorCode:channelDeliveryErrorCode(e),includeTurn:!1,outcome:`failed`})),await h?.flush()},_=createSessionEventSink({abortSignal:e.abortSignal,adapter:o,bundle:s,ctx:a,effectiveAgent:c,instrumentation:h,isFirstTurn:g.sequence===0,sessionWritable:e.sessionWritable,sessionId:p.sessionId}),{adapterCtx:v,dynamicConnections:y,effectiveNode:b,handleEvent:x}=_;try{let S=n!==void 0&&!isHarnessBetweenTurns(p)?structuredClone(v.state):void 0,C;if(n!==void 0){let e=[];try{for(let t of n.payloads){let n=o.deliver?await o.deliver(t,v):defaultDeliverResult(t);n!=null&&e.push(f===void 0?n:markBackgroundTaskStepInput(n))}}catch(e){throw await failChannelDeliveries(e),e}C=e.length===0?void 0:e.reduce(coalesceTurnInputs)}let w=n!==void 0&&C===void 0&&!isHarnessBetweenTurns(p);if(w)d===void 0?a.delete(AuthKey):a.set(AuthKey,d),v.state=S;else if(t!==void 0&&a.set(TurnTaskDeliveryKey,`none`),t?.payloads.some(e=>e.message!==void 0)){let e=t.deliveryMetadata?.map(e=>e.deliveryId)??[];a.set(TurnDeliveryIdsKey,g.turnId?[...new Set([...a.get(TurnDeliveryIdsKey)??[],...e])]:e)}else!g.sessionStarted&&a.get(ChannelDeliveryKey)!==void 0&&a.set(TurnDeliveryIdsKey,[a.require(ChannelDeliveryKey).deliveryId]);r!==void 0&&(r.acceptedAtMsByCallId!==void 0&&a.set(RuntimeActionSettlementTimesKey,r.acceptedAtMsByCallId),C={...C,runtimeActionResults:r.results});let T;if(C!==void 0&&f!==void 0){let e=resolveTaskDeliveryContext({state:i.state,taskDeliveryId:f.taskDeliveryId});e!==void 0&&(a.set(TurnTaskDeliveryKey,e.phase),T=e.rootTurnId,C={...C,context:[...C.context??[],e.context]})}activityCohort.updateActivityRootForDelivery({activeTurnId:activeTurnId(g),ctx:a,delivery:w?void 0:t,sessionState:i.state,taskRootTurnId:T});let E=a.get(TurnTaskDeliveryKey);if(E===`none`||E===`initiating`){let e=resolveInitiatingTaskContext({state:i.state,turnId:activeTurnId(g)});e!==void 0&&a.set(TurnTaskDeliveryKey,e.phase)}if(t!==void 0){let e={...o,state:{...v.state}};setChannelContext(a,e)}if(n!==void 0&&C===void 0&&isHarnessBetweenTurns(p)){await contextStorage.run(a,()=>h?.instrumentChannelDelivery({ctx:a,includeTurn:!1,outcome:`completed`})),await h?.flush();let t=reconcileSessionContinuationToken(a,p),n=serializeContext(a),r=t===p?e.sessionState:createDurableSessionState({session:t});return{action:`park`,...derivePendingState(t),serializedContext:n,sessionState:r}}let D=s.subagentRegistry.dynamicResolvers??[],O=s.resolvedAgent.dynamicToolResolvers??[],k=buildRuntimeIdentity(b);try{let e=process.env.VERCEL_DEPLOYMENT_ID?.trim(),t=e?`deployment:${e}`:await resolveRuntimeCompiledArtifactsVersionedCacheKey(s.compiledArtifactsSource),n=g.sessionStarted;if(a.setVirtualContext(StaticModelReferenceKey,c.turnAgent.model??null),!n)a.set(SessionDynamicSubagentRuntimeRevisionKey,t),a.set(SessionDynamicToolRuntimeRevisionKey,t);else{let e=createSessionStartedEvent({runtime:k});await Promise.all([refreshDynamicSessionSubagentsForRuntimeRevision({ctx:a,resolvers:D,event:e,messages:m.initial.messages,runtimeRevision:t}),refreshDynamicSessionToolsForRuntimeRevision({ctx:a,resolvers:O,event:e,messages:m.initial.messages,runtimeRevision:t})]),await rebindMissingCompiledDynamicToolCallbacks({ctx:a,event:createTurnStartedEvent({sequence:g.sequence,turnId:activeTurnId(g)}),messages:m.initial.messages,resolvers:O})}}catch(e){throw await failChannelDeliveries(e),e}let A=a.require(ModeKey),j=s.resolvedAgent.config?.experimental?.workflow?.modelCallsPerStep??1,M=a.get(CapabilitiesKey),runHarnessStep=async(t,n)=>{let r=refreshSessionFromTurnAgent({compactionOverrides:{thresholdPercent:c.thresholdPercent},session:t,turnAgent:c.turnAgent});return createExecutionNodeStep({steeringSignal:e.steeringSignal,abortSignal:e.abortSignal,capabilities:M,clearOnly:e.input?.control===`clear`,compactOnly:e.input?.control===`compact`,createRuntime:createWorkflowRuntime,handleEvent:x,historyProjector:m.projector,historyView:m.prepare(r),instrumentation:h,mode:A,modelResolutionScope:{moduleMap:s.moduleMap,nodeId:s.nodeId},node:b})(r,n)},N,P;try{throwIfTurnAborted(e.abortSignal),P=await runModelCallBatch({steeringSignal:e.steeringSignal,initialInput:C,initialSession:p,modelCallsPerStep:j,runStep:async({firstCall:t,session:n,stepInput:r})=>{let i=await runBackgroundStep(a,n,async e=>{a.setVirtualContext(HandleEventKey,x),a.setVirtualContext(StaticModelReferenceKey,c.turnAgent.model??null);let n=t?resolveEffectiveOutputSchema({agentOutputSchema:c.turnAgent.outputSchema,input:C,mode:A,session:e}):e;if(await y.rehydrate(getHarnessEmissionState(n.state),k,isHarnessBetweenTurns(n)),t&&u){let e=getHarnessEmissionState(n.state);if(isHarnessBetweenTurns(n)){prepareDynamicInstructionPreamble(a,m.messages(n));let t=[],r=await prepareWorkflowPreambleTrace({emissionState:e,instrumentation:h});try{e=await emitTurnPreamble(x,{},e,k,r)}finally{t=drainDynamicInstructionUserMessages(a),n={...n,history:[...n.history,...t]}}n=setHarnessEmissionState(n,e)}for(let{authorization:t,result:n}of u){let r=l?.challenges.find(e=>e.attemptId===n.attemptId)?.candidateId;await x(createAuthorizationCompletedEvent({attemptId:n.attemptId,authorization:t,candidateId:r,name:n.name,outcome:`authorized`,sequence:e.sequence,stepIndex:e.stepIndex,turnId:e.turnId}))}}return runHarnessStep(n,r)});return throwIfTurnAborted(e.abortSignal),N={result:i,serializedContext:serializeContext(a)},i}})}catch(t){if(!isTurnCancellation(t)&&e.abortSignal?.aborted!==!0)throw await failChannelDeliveries(t),t;let n=readRetainedBackgroundToolResult(a);return h?.rememberBackgroundTasks(n?.backgroundTasks??[]),createCancelledModelCallBatchResult({beforeBatchContext:e.serializedContext,checkpoint:N,ctx:a,initialSession:p,stepInput:C})}h?.rememberBackgroundTasks(P.backgroundTasks??[]);let F=reconcileSessionContinuationToken(a,P.session);agentTraceState.pruneAgentTraceState(a,F.sessionId,F.state);let I=serializeContext(a);P={...P,session:F};let L=resolveSessionStepResult(P,I,A,e.serializedContext);return L.action===`done`&&await _.close(),L}finally{_.release()}}export{turnStep};

package/dist/src/execution/session/turn.d.ts

@@ -0,0 +1,31 @@
+import type { SessionCapabilities } from "#channel/types.js";
+import { type SessionInputQueue } from "#execution/session/input-queue.js";
+import type { SessionInboxReader } from "#execution/session-inbox/inbox.js";
+import type { SessionStateCursor } from "#execution/session/state-cursor.js";
+import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";
+import type { TurnOutcome, TurnStepPayload } from "#execution/session/turn-step-types.js";
+import type { RunMode } from "#shared/run-mode.js";
+import type { RuntimeActionResult } from "#shared/action-types.js";
+export interface SessionExecutionInput {
+    readonly capabilities?: SessionCapabilities;
+    readonly cursor: SessionStateCursor;
+    readonly inbox: SessionInboxReader;
+    readonly mode: RunMode;
+    readonly queue: SessionInputQueue;
+    readonly sessionId: string;
+}
+/**
+ * Executes conversational turns inside the owning session workflow: runs
+ * `turnStep`, services the inbox at committed boundaries, coordinates waits,
+ * and settles locally. There is no child run and no transport protocol.
+ */
+export declare class SessionExecution {
+    private readonly input;
+    constructor(input: SessionExecutionInput);
+    get cursor(): SessionStateCursor;
+    runTurn(delivery: TurnStepPayload | undefined): Promise<TurnOutcome>;
+    private runTurnSteps;
+    handleWorkflowMessage(message: WorkflowToolRunMessage): Promise<RuntimeActionResult | undefined>;
+    private finishCancelledTurn;
+    private waitForRuntimeActionResults;
+}

package/dist/src/execution/session/turn.js

@@ -0,0 +1 @@
+import{sessionCommandHookToken,sessionInboxHookToken}from"#execution/session-inbox/address.js";import{coalesceDeliveries}from"#harness/messages.js";import{getWorkflowMetadata}from"#compiled/@workflow/core/index.js";import{isInboxSubagentResultFromRecordedWorkflowToolRun,isInboxToolResultFromRecordedWorkflowToolRun}from"#harness/workflow-tool-runs.js";import{activeTurnId}from"#harness/active-turn-id.js";import{decodeSessionInboxPayload}from"#execution/session-inbox/protocol.js";import{isInboxSubagentResultFromRunningHandle}from"#subagents/handles/query.js";import{routeSelectedDelivery}from"#execution/session/route-selected-delivery.js";import{admitSessionInboxPayload,applySessionCancellation}from"#execution/session/admission.js";import{cancelDescendantTurnsStep}from"#execution/cancel-descendant-turns-step.js";import{isSteeringDelivery}from"#execution/session/input-queue.js";import{routeDeliverToChildren}from"#execution/route-child-delivery.js";import{TurnCancelledError}from"#harness/turn-cancellation.js";import{resolveWorkflowCallbackBaseUrl}from"#execution/workflow-callback-url.js";import{dispatchCoordinationStep}from"#execution/coordination-dispatch-step.js";import{acknowledgeDelegatedTasksStep}from"#execution/tasks/parent/delegate.js";import{handleWorkflowToolRunMessage}from"#execution/session-workflow-tool-run.js";import{turnStep}from"#execution/session/turn-step.js";import{resolveRuntimeActionResultsForCallIds}from"#runtime/actions/results.js";var SessionExecution=class{input;constructor(e){this.input=e}get cursor(){return this.input.cursor}async runTurn(e){let t=new ActiveTurn(this.input,e?.delivery?.caller?.callId);try{return await this.runTurnSteps(t,e)}finally{t.dispose()}}async runTurnSteps(e,t){let n=t;for(;;){let{cursor:t}=this.input,r=t.serializedContext,i=await turnStep(t.createStepInput(n,{abortSignal:e.signal,steeringSignal:e.steeringSignal})),a=i.action===`park`?i.pendingCoordinationCallIds:void 0,o=(i.backgroundTasks?.length??0)>0;if(o){if(i.backgroundTaskState===void 0)throw Error(`Background tasks were returned without their committed session state.`);await t.apply({serializedContext:i.backgroundTaskContext??r,sessionState:i.backgroundTaskState}),await acknowledgeDelegatedTasksStep({tasks:i.backgroundTasks??[]})}if(await t.apply({serializedContext:i.serializedContext,sessionState:i.action===`cancelled`||e.signal.aborted?i.backgroundTaskState??i.sessionState:i.sessionState}),await e.admitBoundary(),e.resetSteering(),i.action===`cancelled`||e.signal.aborted&&(a===void 0||o))return await this.finishCancelledTurn();if(i.action===`done`)return{isError:i.isError,kind:`done`,output:i.output??``,usage:i.usage,usageDelta:i.usageDelta};if(a!==void 0&&i.action===`park`){let r=await dispatchCoordinationStep({action:i.action,callbackBaseUrl:resolveWorkflowCallbackBaseUrl(getWorkflowMetadata().url),workflowToolRunOwner:{inbox:sessionInboxHookToken(sessionCommandHookToken(this.input.sessionId))},sessionWritable:t.sessionWritable,serializedContext:t.serializedContext,sessionState:t.sessionState}),o=r.results.length===0?void 0:Date.now();await t.apply(r),await acknowledgeDelegatedTasksStep({tasks:r.pendingTasks});let s=await this.waitForRuntimeActionResults({initialAcceptedAtMs:o,initialResults:r.results,pendingCallIds:a,turn:e});if(s===`cancelled`)return await this.finishCancelledTurn();n={delivery:await e.takeSteering(),runtimeResults:s};continue}if(i.action===`park`){if(!(i.hasPendingAuthorization||i.hasPendingInputBatch&&this.input.capabilities?.requestInput===!0||this.input.mode===`conversation`))throw Error("Task mode cannot wait for follow-up input (`next: null`).");return{authorizationAttemptIds:i.authorizationAttemptIds,kind:`park`,settled:i.settled}}let s=await e.takeSteering();n=s===void 0?void 0:{delivery:s}}}async handleWorkflowMessage(e){return await handleWorkflowToolRunMessage({callbackMetadataUrl:getWorkflowMetadata().url,cursor:this.input.cursor,message:e})}async finishCancelledTurn(){let{cursor:e}=this.input;return await cancelDescendantTurnsStep({serializedContext:e.serializedContext,sessionState:e.sessionState}),{cancelled:!0,kind:`park`}}async waitForRuntimeActionResults(e){let t=[...e.initialResults],n=new Map;if(e.initialAcceptedAtMs!==void 0)for(let r of t)n.set(r.callId,e.initialAcceptedAtMs);for(;;){let r=resolveRuntimeActionResultsForCallIds({pendingCallIds:e.pendingCallIds,results:t});if(r!==void 0)return{acceptedAtMsByCallId:Object.fromEntries(r.map(e=>[e.callId,n.get(e.callId)])),results:r};let i=await e.turn.nextRuntimeEvent();if(i===`cancelled`)return i;if(i.kind===`runtime-action-result`){let e=this.input.cursor.sessionState.snapshot.session.state,r=i.results.filter(t=>t.kind===`tool-result`?isInboxToolResultFromRecordedWorkflowToolRun(e,t):t.kind===`subagent-result`?t.origin===`child`&&isInboxSubagentResultFromRunningHandle(e,t)||isInboxSubagentResultFromRecordedWorkflowToolRun(e,t):!1);if(r.length>0){let e=Date.now();t.push(...r);for(let t of r)n.set(t.callId,e)}continue}let a=await this.handleWorkflowMessage(i.message);a!==void 0&&(t.push(a),n.set(a.callId,Date.now()))}}},ActiveTurn=class{admitted=new Set;routedToChildren=new Set;runtimeResults=[];controller=new AbortController;expectedTurnId;input;callerCallId;unsubscribe;unsubscribeDelivery;steeringController=new AbortController;constructor(e,t){this.input=e,this.callerCallId=t,this.expectedTurnId=activeTurnId(e.cursor.sessionState.emissionState),this.unsubscribe=e.inbox.onInterrupt(e=>{this.cancelsThisTurn(e)&&this.abort()}),this.unsubscribeDelivery=e.inbox.onDelivery(this.signalSteering)}signalSteering=e=>{let t;try{t=decodeSessionInboxPayload(e)}catch{return}t.kind===`deliver`&&isSteeringDelivery(t,this.callerCallId)&&!this.input.cursor.sessionState.hasProxyInputRequests&&t.payloads.some(e=>e.message!==void 0&&e.inputResponses===void 0&&e.task===void 0)&&this.steeringController.abort()};get signal(){return this.controller.signal}dispose(){this.unsubscribe(),this.unsubscribeDelivery()}get steeringSignal(){return this.steeringController.signal}resetSteering(){this.steeringController.signal.aborted&&(this.unsubscribeDelivery(),this.steeringController=new AbortController,this.unsubscribeDelivery=this.input.inbox.onDelivery(this.signalSteering))}async admitBoundary(){let e=this.input.inbox.drain();for(let t of e)await this.admit(t)}async takeSteering(){let e=[];for(;;){let t=this.input.queue.takeSteering(this.admitted,this.callerCallId);if(t===void 0)break;for(let e of t.sequences)this.admitted.delete(e);let n=await routeSelectedDelivery(t,this.input.cursor);if(n.kind===`cancel-turn`){this.abort();break}n.kind===`turn`&&e.push(n.delivery)}if(e.length!==0)return e.length===1?e[0]:coalesceDeliveries(e)}async nextRuntimeEvent(){for(;;){if(this.signal.aborted)return`cancelled`;let e=this.runtimeResults.shift();if(e!==void 0)return e;let t=await this.input.inbox.next();if(t===void 0)throw Error(`Session inbox closed before runtime actions completed.`);await this.admit(t),await this.routeAdmittedToChildren()}}cancelsThisTurn(e){return e.kind===`reset`?!0:e.kind===`cancel`?e.turnId===void 0||e.turnId===this.expectedTurnId:!1}async admit(e){let t=await admitSessionInboxPayload(e,this.input);switch(t.kind){case`delivery`:this.admitted.add(t.admission.sequence);return;case`runtime-action-result`:this.runtimeResults.push({kind:`runtime-action-result`,results:t.payload.results});return;case`workflow`:this.runtimeResults.push({kind:`workflow`,message:t.message});return;case`cancel`:if(!this.cancelsThisTurn(e))return;await applySessionCancellation(t.command,this.input),this.abort();return;case`consumed`:return}}async routeAdmittedToChildren(){for(let e of this.admitted){if(this.routedToChildren.has(e))continue;let t=this.input.queue.delivery(e);if(t===void 0){this.admitted.delete(e);continue}this.routedToChildren.add(e);let n=await routeDeliverToChildren({delivery:t,sessionWritable:this.input.cursor.sessionWritable,serializedContext:this.input.cursor.serializedContext,sessionState:this.input.cursor.sessionState});if(await this.input.cursor.apply(n),n.kind===`cancel-turn`){this.input.queue.replaceDelivery(e,void 0),this.admitted.delete(e),this.abort();return}this.input.queue.replaceDelivery(e,n.remainder),n.remainder===void 0&&this.admitted.delete(e)}}abort(){this.controller.signal.aborted||this.controller.abort(new TurnCancelledError)}};export{SessionExecution};

package/dist/src/execution/session-inbox/address.d.ts

@@ -0,0 +1,21 @@
+/** Serialized-context key advertising a session's stable inbox. */
+export declare const SESSION_INBOX_CONTEXT_KEY = "eve.sessionInbox";
+/** Hook metadata key that keeps public identity separate from hook ownership. */
+export declare const SESSION_INBOX_SESSION_ID_METADATA_KEY = "sessionId";
+/** Stable inbox coordinates. The owner and deployment are intentionally absent. */
+export interface SessionInboxAddress {
+    readonly sessionId: string;
+}
+export declare function isSessionInboxAddress(value: unknown): value is SessionInboxAddress;
+/** Returns whether a token belongs to eve's framework-reserved session namespace. */
+export declare function isReservedSessionCommandToken(token: string): boolean;
+/** Logical stable command inbox token for a session. */
+export declare function sessionCommandHookToken(sessionId: string): string;
+/**
+ * Physical hook token for a logical session address. Applied exactly where a
+ * hook is created or resumed, so current-generation hooks stay disjoint from
+ * hooks owned by pre-cutover drivers that used the logical token directly.
+ */
+export declare function sessionInboxHookToken(token: string): string;
+/** Marker a releasing owner leaves so ingress can tell "handoff in progress" from "no session". */
+export declare function sessionHandoffMarkerToken(token: string): string;

package/dist/src/execution/session-inbox/address.js

@@ -0,0 +1 @@
+const SESSION_INBOX_CONTEXT_KEY=`eve.sessionInbox`,SESSION_INBOX_SESSION_ID_METADATA_KEY=`sessionId`;function isSessionInboxAddress(e){return typeof e==`object`&&!!e&&`sessionId`in e&&typeof e.sessionId==`string`&&e.sessionId.length>0&&!e.sessionId.includes(`:`)}function isReservedSessionCommandToken(e){return e.startsWith(`eve:session:`)||e.startsWith(`eve:inbox:`)}function sessionCommandHookToken(e){return`eve:session:${e}:inbox`}function sessionInboxHookToken(e){return`eve:inbox:v1:${e}`}function sessionHandoffMarkerToken(e){return`eve:inbox:handoff:${e}`}export{SESSION_INBOX_CONTEXT_KEY,SESSION_INBOX_SESSION_ID_METADATA_KEY,isReservedSessionCommandToken,isSessionInboxAddress,sessionCommandHookToken,sessionHandoffMarkerToken,sessionInboxHookToken};