The Open Framework for Building Agents
perf(eve): parallelize initial session boot (#4450)
Casey Gowrie282802a39276
diff --git a/.changeset/parallel-session-boot.md b/.changeset/parallel-session-boot.mdnew file mode 100644index 000000000..7e89d4798--- /dev/null+++ b/.changeset/parallel-session-boot.md@@ -0,0 +1,5 @@+---+"eve": patch+---++Reduce new-session startup latency by overlapping session creation with timeout startup and first-turn cancellation and steering hook registration after inbox ownership is ready.diff --git a/packages/eve/src/execution/legacy-session/turn-workflow.ts b/packages/eve/src/execution/legacy-session/turn-workflow.tsindex 39fd57443..077121e34 100644--- a/packages/eve/src/execution/legacy-session/turn-workflow.ts+++ b/packages/eve/src/execution/legacy-session/turn-workflow.ts@@ -4,6 +4,7 @@ import { sessionCommandHookToken } from "#execution/session-inbox/address.js";import { createSessionInbox } from "#execution/session-inbox/inbox.js";import { failSession, runPreparedSession } from "#execution/session/program.js";import { sessionTimeoutDeadline } from "#execution/session/timeout.js";+import { createSessionTimeoutControl } from "#execution/session/timeout-control.js";import { completeLegacyDriverStep } from "./completion-step.js";import { interruptLegacySessionStep } from "./interrupt-step.js";import { prepareLegacySessionStep } from "./prepare-step.js";@@ -42,6 +43,7 @@ export async function turnWorkflow(rawInput: unknown): Promise<void> {sessionWritable,});}+ const timeoutDeadline = sessionTimeoutDeadline(prepared.sessionTimeoutMs, Date.now());await runPreparedSession({anchor: {@@ -71,8 +73,12 @@ export async function turnWorkflow(rawInput: unknown): Promise<void> {serializedContext: interrupted.serializedContext,sessionId,sessionState: interrupted.sessionState,+ sessionTimeoutControl:+ timeoutDeadline === undefined+ ? undefined+ : createSessionTimeoutControl({ deadline: timeoutDeadline, sessionId }),sessionTimeoutMs: prepared.sessionTimeoutMs,- sessionTimeoutDeadline: sessionTimeoutDeadline(prepared.sessionTimeoutMs, Date.now()),+ sessionTimeoutDeadline: timeoutDeadline,sessionWritable,},inbox,diff --git a/packages/eve/src/execution/session/active-turn.ts b/packages/eve/src/execution/session/active-turn.tsindex b442682a1..81bf79949 100644--- a/packages/eve/src/execution/session/active-turn.ts+++ b/packages/eve/src/execution/session/active-turn.ts@@ -10,6 +10,7 @@ import {} from "#execution/session/input-queue.js";import { routeSelectedDelivery } from "#execution/session/route-selected-delivery.js";import type { SessionExecutionInput } from "#execution/session/turn.js";+import { createTurnControl, type TurnControl } from "#execution/session/turn-control.js";import type { SessionInboxPayload } from "#execution/session-inbox/inbox.js";import { decodeSessionInboxPayload } from "#execution/session-inbox/protocol.js";import type { WorkflowToolRunMessage } from "#execution/tools/workflow/messages.js";@@ -45,14 +46,14 @@ export class ActiveTurn {private readonly routedToChildren = new Set<number>();private readonly mappedForHeldRequest = new Set<number>();private readonly runtimeResults: RuntimeEvent[] = [];- private readonly controller = new AbortController();+ private readonly controller: AbortController;private readonly expectedTurnId: string;private readonly input: SessionExecutionInput;/** Who alone steers the turn: its principal, or its delegated caller. */private readonly identity: SteeringTurn;private readonly unsubscribe: () => void;private unsubscribeDelivery: () => void;- private steeringController = new AbortController();+ private steeringController: AbortController;/** The delegated caller of the latest message the turn read. */caller: TurnCaller | undefined;/** A step of this turn compacted the history. */@@ -61,7 +62,10 @@ export class ActiveTurn {constructor(input: SessionExecutionInput,owner: { readonly caller: TurnCaller | undefined; readonly principal: string },+ control: TurnControl = createTurnControl(),) {+ this.controller = control.cancellation;+ this.steeringController = control.steering;this.input = input;this.caller = owner.caller;this.identity = { callerCallId: owner.caller?.callId, principal: owner.principal };diff --git a/packages/eve/src/execution/session/entry.integration.test.ts b/packages/eve/src/execution/session/entry.integration.test.tsindex b5b1d2734..3fd273a2b 100644--- a/packages/eve/src/execution/session/entry.integration.test.ts+++ b/packages/eve/src/execution/session/entry.integration.test.ts@@ -43,6 +43,54 @@ afterEach(() => {});describe("workflowEntry integration", () => {+ it("registers first-turn abort hooks before a prewarmed session receives a message", async () => {+ const runtime = await createTestRuntime({ agent: { name: "workflow-entry-turn-prewarm" } });++ await runtime.run(async () => {+ const run = await start(workflowEntry, [+ {+ kind: "initial",+ ownerDeploymentId: "dpl_inline",+ input: {},+ serializedContext: buildSerializedContext({ channelKind: "http" }),+ sessionTimeoutMs: false,+ },+ ]);+ const stream = captureTurnEvents(run);+ try {+ await waitForHook(+ { runId: run.runId },+ { token: sessionInboxHookToken(sessionCommandHookToken(run.runId)) },+ );+ let abortTokensBeforeMessage: string[] = [];+ await vi.waitFor(async () => {+ abortTokensBeforeMessage = (+ await (await getWorld()).hooks.list({ runId: run.runId })+ ).data+ .map((hook) => hook.token)+ .filter((token) => token.startsWith("abrt_"));+ expect(abortTokensBeforeMessage).toHaveLength(2);+ });++ await resumeHook(sessionInboxHookToken(sessionCommandHookToken(run.runId)), {+ kind: "send",+ payload: { message: "Say hello." },+ });+ await stream.nextTurn();++ const abortTokensAfterTurn = (+ await (await getWorld()).hooks.list({ runId: run.runId })+ ).data+ .map((hook) => hook.token)+ .filter((token) => token.startsWith("abrt_"));+ expect(abortTokensAfterTurn).toEqual(abortTokensBeforeMessage);+ } finally {+ stream.dispose();+ await run.cancel();+ }+ });+ });+it("parks before initialization and initializes with the first message identity and title", async () => {let initializedSessions = 0;let initializedAuth: unknown;@@ -86,8 +134,8 @@ describe("workflowEntry integration", () => {{ runId: run.runId },{ token: sessionInboxHookToken(sessionCommandHookToken(run.runId)) },);- await expectHookClaims(run.runId, [sessionCommandHookToken(run.runId)], {- turnStarted: false,+ await vi.waitFor(async () => {+ await expectHookClaims(run.runId, [sessionCommandHookToken(run.runId)]);});const sessionRuntime = createWorkflowRuntime({diff --git a/packages/eve/src/execution/session/entry.test.ts b/packages/eve/src/execution/session/entry.test.tsnew file mode 100644index 000000000..6d0b2fbd5--- /dev/null+++ b/packages/eve/src/execution/session/entry.test.ts@@ -0,0 +1,274 @@+import { beforeEach, describe, expect, it, vi } from "vitest";++import { bootInitialOwner } from "#execution/session/entry.js";+import { createSessionStep } from "#execution/create-session-step.js";+import { createSessionInbox } from "#execution/session-inbox/inbox.js";+import {+ cancelSessionTimeoutStep,+ startSessionTimeoutStep,+} from "#execution/session/timeout-steps.js";+import { resolveInitialTurnCallerStep } from "#subagents/parent-notification.js";+import { hasDelegatedSessionContext } from "#execution/delegated-session-context.js";+import { settleContinuationConflictStep } from "#execution/continuation-conflict-step.js";+import { createTurnControl } from "#execution/session/turn-control.js";++type Deferred<T> = {+ readonly promise: Promise<T>;+ resolve(value: T): void;+ reject(reason: unknown): void;+};++const mocks = vi.hoisted(() => ({+ failSession: vi.fn(async ({ error }: { error: unknown }) => {+ throw error;+ }),+ getWritable: vi.fn(() => new WritableStream<Uint8Array>()),+}));++vi.mock("#compiled/@workflow/core/index.js", () => ({+ getWorkflowMetadata: () => ({+ workflowRunId: "session-1",+ workflowStartedAt: new Date("2026-02-01T00:00:00.000Z"),+ }),+ getWritable: mocks.getWritable,+}));++vi.mock("./program.js", () => ({+ failSession: mocks.failSession,+ runPreparedSession: vi.fn(),+}));++vi.mock("../create-session-step.js", () => ({ createSessionStep: vi.fn() }));+vi.mock("../session-inbox/inbox.js", () => ({ createSessionInbox: vi.fn() }));+vi.mock("./timeout-steps.js", () => ({+ cancelSessionTimeoutStep: vi.fn(),+ startSessionTimeoutStep: vi.fn(),+}));+vi.mock("./turn-control.js", () => ({ createTurnControl: vi.fn() }));+vi.mock("#subagents/parent-notification.js", () => ({+ resolveInitialTurnCallerStep: vi.fn(),+}));+vi.mock("../delegated-session-context.js", () => ({ hasDelegatedSessionContext: vi.fn() }));+vi.mock("../continuation-conflict-step.js", () => ({+ settleContinuationConflictStep: vi.fn(),+}));+vi.mock("../hook-ownership.js", () => ({+ isHookConflictError: (error: unknown) =>+ typeof error === "object" && error !== null && "hookConflict" in error,+}));+vi.mock("../eve-workflow-attributes.js", () => ({+ readChannelRequestId: vi.fn(),+ readRootSessionId: vi.fn(),+}));++function deferred<T>(): Deferred<T> {+ let resolve!: (value: T) => void;+ let reject!: (reason: unknown) => void;+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {+ resolve = resolvePromise;+ reject = rejectPromise;+ });+ return { promise, reject, resolve };+}++function initialInput(overrides: Record<string, unknown> = {}) {+ return {+ input: { message: "hello" },+ kind: "initial" as const,+ ownerDeploymentId: "deployment-1",+ serializedContext: {+ "eve.bundle": { source: { kind: "bundled" } },+ ...(overrides.serializedContext as Record<string, unknown> | undefined),+ },+ ...overrides,+ } as Parameters<typeof bootInitialOwner>[0];+}++function createInbox() {+ return {+ claimSessionHook: vi.fn(async () => {}),+ dispose: vi.fn(async () => {}),+ };+}++beforeEach(() => {+ vi.clearAllMocks();+ vi.mocked(createSessionStep).mockResolvedValue({ history: [], state: {} } as never);+ vi.mocked(startSessionTimeoutStep).mockResolvedValue({ runId: "timeout-run-1" });+ vi.mocked(cancelSessionTimeoutStep).mockResolvedValue(undefined);+ vi.mocked(createTurnControl).mockImplementation(() => ({+ cancellation: new AbortController(),+ dispose: vi.fn(),+ steering: new AbortController(),+ }));+ vi.mocked(resolveInitialTurnCallerStep).mockResolvedValue(undefined);+ vi.mocked(hasDelegatedSessionContext).mockReturnValue(false);+ vi.mocked(settleContinuationConflictStep).mockResolvedValue(undefined);+});++describe("bootInitialOwner timeout startup", () => {+ it("prepares controls and starts the timeout while session creation is pending", async () => {+ const sessionCreation = deferred<never>();+ const timeoutStartup = deferred<{ runId: string }>();+ const inbox = createInbox();+ vi.mocked(createSessionStep).mockReturnValue(sessionCreation.promise);+ vi.mocked(startSessionTimeoutStep).mockReturnValue(timeoutStartup.promise);+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);++ const bootPromise = bootInitialOwner(initialInput(), "session-1");++ await vi.waitFor(() => expect(startSessionTimeoutStep).toHaveBeenCalledOnce());+ expect(createTurnControl).toHaveBeenCalledOnce();+ expect(inbox.claimSessionHook).toHaveBeenCalledWith("eve:session:session-1:inbox");+ sessionCreation.resolve({ history: [], state: {} } as never);++ const boot = await bootPromise;+ expect(boot?.session.initialTurnControl).toBeDefined();+ expect(boot?.session.sessionTimeoutControl).toBeDefined();+ const loopStart = boot!.session.sessionTimeoutControl!.start();+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ timeoutStartup.resolve({ runId: "timeout-run-1" });+ await loopStart;+ });++ it("waits for stable and alias ownership before starting the timeout", async () => {+ const stableClaim = deferred<void>();+ const aliasClaim = deferred<void>();+ const inbox = createInbox();+ inbox.claimSessionHook+ .mockImplementationOnce(async () => await stableClaim.promise)+ .mockImplementationOnce(async () => await aliasClaim.promise);+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);++ const bootPromise = bootInitialOwner(+ initialInput({+ serializedContext: {+ "eve.bundle": { source: { kind: "bundled" } },+ "eve.continuationToken": "channel:conversation-1",+ },+ }),+ "session-1",+ );++ await vi.waitFor(() => expect(inbox.claimSessionHook).toHaveBeenCalledTimes(2));+ expect(createTurnControl).not.toHaveBeenCalled();+ expect(startSessionTimeoutStep).not.toHaveBeenCalled();+ stableClaim.resolve();+ await Promise.resolve();+ expect(createTurnControl).not.toHaveBeenCalled();+ expect(startSessionTimeoutStep).not.toHaveBeenCalled();+ aliasClaim.resolve();+ await expect(bootPromise).resolves.toBeDefined();+ expect(createTurnControl).toHaveBeenCalledOnce();+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ });++ it("settles an alias conflict without starting a timeout", async () => {+ const inbox = createInbox();+ inbox.claimSessionHook+ .mockResolvedValueOnce(undefined)+ .mockRejectedValueOnce({ hookConflict: true });+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);+ const continuationConflictCommand = { kind: "reset", reason: "replaced" } as const;++ await expect(+ bootInitialOwner(+ initialInput({+ continuationConflictCommand,+ serializedContext: {+ "eve.bundle": { source: { kind: "bundled" } },+ "eve.continuationToken": "channel:conversation-1",+ },+ }),+ "session-1",+ ),+ ).resolves.toBeUndefined();++ expect(settleContinuationConflictStep).toHaveBeenCalledWith({+ command: continuationConflictCommand,+ continuationToken: "channel:conversation-1",+ });+ expect(createTurnControl).not.toHaveBeenCalled();+ expect(startSessionTimeoutStep).not.toHaveBeenCalled();+ expect(inbox.dispose).toHaveBeenCalledOnce();+ });++ it("cancels a started timeout when session creation fails", async () => {+ const sessionCreation = deferred<never>();+ const inbox = createInbox();+ vi.mocked(createSessionStep).mockReturnValue(sessionCreation.promise);+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);+ const failure = new Error("session creation failed");++ const bootPromise = bootInitialOwner(initialInput(), "session-1");+ await vi.waitFor(() => expect(startSessionTimeoutStep).toHaveBeenCalledOnce());+ sessionCreation.reject(failure);++ await expect(bootPromise).rejects.toBe(failure);+ expect(cancelSessionTimeoutStep).toHaveBeenCalledWith({ runId: "timeout-run-1" });+ expect(vi.mocked(createTurnControl).mock.results[0]?.value.dispose).toHaveBeenCalledOnce();+ expect(inbox.dispose).toHaveBeenCalledOnce();+ });++ it("cancels a started timeout when delegated caller resolution fails", async () => {+ const callerResolution = deferred<never>();+ const inbox = createInbox();+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);+ vi.mocked(hasDelegatedSessionContext).mockReturnValue(true);+ vi.mocked(resolveInitialTurnCallerStep).mockReturnValue(callerResolution.promise);+ const failure = new Error("caller resolution failed");++ const bootPromise = bootInitialOwner(initialInput(), "session-1");+ await vi.waitFor(() => expect(startSessionTimeoutStep).toHaveBeenCalledOnce());+ callerResolution.reject(failure);++ await expect(bootPromise).rejects.toBe(failure);+ expect(cancelSessionTimeoutStep).toHaveBeenCalledWith({ runId: "timeout-run-1" });+ expect(vi.mocked(createTurnControl).mock.results[0]?.value.dispose).toHaveBeenCalledOnce();+ expect(inbox.dispose).toHaveBeenCalledOnce();+ });++ it("carries timeout startup failures into the session loop", async () => {+ const inbox = createInbox();+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);+ const failure = new Error("timeout startup failed");+ vi.mocked(startSessionTimeoutStep).mockRejectedValue(failure);++ const boot = await bootInitialOwner(initialInput(), "session-1");++ await expect(boot?.session.sessionTimeoutControl?.start()).rejects.toBe(failure);+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ expect(cancelSessionTimeoutStep).not.toHaveBeenCalled();+ expect(inbox.dispose).not.toHaveBeenCalled();+ });++ it("does not create a timeout when session timeouts are disabled", async () => {+ const inbox = createInbox();+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);++ const boot = await bootInitialOwner(initialInput({ sessionTimeoutMs: false }), "session-1");++ expect(boot?.session.initialTurnControl).toBeDefined();+ expect(boot?.session.sessionTimeoutDeadline).toBeUndefined();+ expect(boot?.session.sessionTimeoutControl).toBeUndefined();+ expect(createTurnControl).toHaveBeenCalledOnce();+ expect(startSessionTimeoutStep).not.toHaveBeenCalled();+ });++ it("does not start a very short timeout until ownership is ready", async () => {+ const ownership = deferred<void>();+ const inbox = createInbox();+ inbox.claimSessionHook.mockImplementationOnce(async () => await ownership.promise);+ vi.mocked(createSessionInbox).mockReturnValue(inbox as never);++ const bootPromise = bootInitialOwner(initialInput({ sessionTimeoutMs: 1 }), "session-1");+ await vi.waitFor(() => expect(inbox.claimSessionHook).toHaveBeenCalledOnce());+ expect(createTurnControl).not.toHaveBeenCalled();+ expect(startSessionTimeoutStep).not.toHaveBeenCalled();+ ownership.resolve();++ await expect(bootPromise).resolves.toBeDefined();+ expect(createTurnControl).toHaveBeenCalledOnce();+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ });+});diff --git a/packages/eve/src/execution/session/entry.ts b/packages/eve/src/execution/session/entry.tsindex 17667d374..948b9f639 100644--- a/packages/eve/src/execution/session/entry.ts+++ b/packages/eve/src/execution/session/entry.ts@@ -11,6 +11,11 @@ import { isHookConflictError } from "#execution/hook-ownership.js";import { createSessionInbox, type SessionInboxHandle } from "#execution/session-inbox/inbox.js";import { sessionHookTokens } from "#execution/session/hook-tokens.js";import { DEFAULT_SESSION_TIMEOUT_MS, sessionTimeoutDeadline } from "#execution/session/timeout.js";+import {+ createSessionTimeoutControl,+ type SessionTimeoutControl,+} from "#execution/session/timeout-control.js";+import { createTurnControl, type TurnControl } from "#execution/session/turn-control.js";import { hasDelegatedSessionContext } from "#execution/delegated-session-context.js";import type { DynamicSubagentAgentConfig } from "#runtime/subagents/dynamic-agent-config.js";import { attachClientContext, readClientContext } from "#internal/client-context.js";@@ -76,8 +81,74 @@ function stampSessionIdentity(};}+interface OwnedInitialSession {+ readonly kind: "owned";+ readonly timeoutControl: SessionTimeoutControl | undefined;+ readonly turnControl: TurnControl;+ dispose(): Promise<void>;+}++type InitialOwnerPreparation = OwnedInitialSession | { readonly kind: "alias-conflict" };++async function prepareInitialOwner(+ inbox: SessionInboxHandle,+ input: {+ readonly continuationToken: string;+ readonly deadline: Date | undefined;+ readonly sessionId: string;+ },+): Promise<InitialOwnerPreparation> {+ const [stableClaim, aliasClaim] = await Promise.allSettled([+ inbox.claimSessionHook(sessionCommandHookToken(input.sessionId)),+ input.continuationToken === ""+ ? Promise.resolve()+ : inbox.claimSessionHook(input.continuationToken),+ ]);+ if (stableClaim.status === "rejected") throw stableClaim.reason;+ if (aliasClaim.status === "rejected") {+ if (isHookConflictError(aliasClaim.reason)) return { kind: "alias-conflict" };+ throw aliasClaim.reason;+ }++ const turnControl = createTurnControl();+ const timeoutControl =+ input.deadline === undefined+ ? undefined+ : createSessionTimeoutControl({ deadline: input.deadline, sessionId: input.sessionId });+ const owner: OwnedInitialSession = {+ kind: "owned",+ timeoutControl,+ turnControl,+ async dispose() {+ turnControl.dispose();+ await timeoutControl?.dispose();+ },+ };+ // The session loop joins this startup. Handling the promise here prevents a+ // rejection from becoming unhandled if another boot branch fails first.+ void timeoutControl?.start().catch(() => {});+ return owner;+}++function unwrapSettled<T>(result: PromiseSettledResult<T>): T {+ if (result.status === "rejected") throw result.reason;+ return result.value;+}++async function disposeInitialBoot(+ inbox: SessionInboxHandle,+ owner: OwnedInitialSession | undefined,+): Promise<void> {+ const [ownerDisposal, inboxDisposal] = await Promise.allSettled([+ owner?.dispose(),+ inbox.dispose(),+ ]);+ if (ownerDisposal.status === "rejected") throw ownerDisposal.reason;+ if (inboxDisposal.status === "rejected") throw inboxDisposal.reason;+}+/** Returns `undefined` when a competing continuation owner already exists. */-async function bootInitialOwner(+export async function bootInitialOwner(input: InitialWorkflowEntryInput,sessionId: string,): Promise<BootOutcome | undefined> {@@ -86,71 +157,80 @@ async function bootInitialOwner(const inbox = createSessionInbox(sessionId);const { workflowStartedAt } = getWorkflowMetadata();const sessionTimeoutMs = input.sessionTimeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;+ const deadline = sessionTimeoutDeadline(sessionTimeoutMs, workflowStartedAt.getTime());const continuationToken = (serializedContext["eve.continuationToken"] as string) || "";const serializedBundle = serializedContext["eve.bundle"] as {source: DurableCompiledArtifactsSource;nodeId?: string;};+ let owner: OwnedInitialSession | undefined;try {- const [sessionCreation, stableClaim, aliasClaim, callerResolution] = await Promise.allSettled([- createSessionStep({- compiledArtifactsSource: serializedBundle.source,- continuationToken,- dynamicSubagentAgentConfig: serializedContext["eve.dynamicSubagentAgentConfig"] as- | DynamicSubagentAgentConfig- | undefined,- inheritedLimits: input.limits,- nodeId: serializedBundle.nodeId,- outputSchema: input.input.outputSchema,- rootSessionId: readRootSessionId(serializedContext),- sessionId,- }),- inbox.claimSessionHook(sessionCommandHookToken(sessionId)),- continuationToken === "" ? Promise.resolve() : inbox.claimSessionHook(continuationToken),- hasDelegatedSessionContext(serializedContext)- ? resolveInitialTurnCallerStep({ serializedContext })- : Promise.resolve(undefined),+ const sessionCreationPromise = createSessionStep({+ compiledArtifactsSource: serializedBundle.source,+ continuationToken,+ dynamicSubagentAgentConfig: serializedContext["eve.dynamicSubagentAgentConfig"] as+ | DynamicSubagentAgentConfig+ | undefined,+ inheritedLimits: input.limits,+ nodeId: serializedBundle.nodeId,+ outputSchema: input.input.outputSchema,+ rootSessionId: readRootSessionId(serializedContext),+ sessionId,+ });+ const ownerPreparationPromise = prepareInitialOwner(inbox, {+ continuationToken,+ deadline,+ sessionId,+ });+ const callerResolutionPromise = hasDelegatedSessionContext(serializedContext)+ ? resolveInitialTurnCallerStep({ serializedContext })+ : Promise.resolve(undefined);+ const [sessionCreation, ownerPreparation, callerResolution] = await Promise.allSettled([+ sessionCreationPromise,+ ownerPreparationPromise,+ callerResolutionPromise,]);- if (sessionCreation.status === "rejected") throw sessionCreation.reason;- if (stableClaim.status === "rejected") throw stableClaim.reason;- if (aliasClaim.status === "rejected") {- if (!isHookConflictError(aliasClaim.reason)) throw aliasClaim.reason;+ if (ownerPreparation.status === "fulfilled" && ownerPreparation.value.kind === "owned") {+ owner = ownerPreparation.value;+ }+ const created = unwrapSettled(sessionCreation);+ const prepared = unwrapSettled(ownerPreparation);+ if (prepared.kind === "alias-conflict") {if (input.continuationConflictCommand !== undefined) {await settleContinuationConflictStep({command: input.continuationConflictCommand,continuationToken,});}- await inbox.dispose();+ await disposeInitialBoot(inbox, owner);return undefined;}- if (callerResolution.status === "rejected") throw callerResolution.reason;+ const caller = unwrapSettled(callerResolution);return {inbox,session: {anchor: { kind: "self" },- caller: callerResolution.value,+ caller,capabilities: serializedContext["eve.capabilities"] as SessionCapabilities | undefined,deploymentId: input.ownerDeploymentId,- history: sessionCreation.value.history,+ history: created.history,start:input.input.message === undefined? { kind: "first-message" }: { input: createInitialDelivery(input, serializedContext), kind: "turn" },+ initialTurnControl: prepared.turnControl,retention: input.retention,serializedContext,sessionId,- sessionState: sessionCreation.value.state,+ sessionState: created.state,+ sessionTimeoutControl: prepared.timeoutControl,sessionTimeoutMs,- sessionTimeoutDeadline: sessionTimeoutDeadline(- sessionTimeoutMs,- workflowStartedAt.getTime(),- ),+ sessionTimeoutDeadline: deadline,sessionWritable,},};} catch (error) {- await inbox.dispose();+ await disposeInitialBoot(inbox, owner);return await failSession({error,serializedContext,@@ -202,7 +282,12 @@ async function bootHandoffOwner(if (childRunIdsToStop.length > 0) {await stopUntrackedChildSessionsStep({ runIds: childRunIdsToStop, sessionId });}- const compaction = input.reason === "compaction";+ const deadline =+ input.reason === "compaction"+ ? input.sessionTimeoutDeadline+ : sessionTimeoutDeadline(checkpoint.sessionTimeoutMs, Date.now());+ const timeoutControl =+ deadline === undefined ? undefined : createSessionTimeoutControl({ deadline, sessionId });return {inbox,session: {@@ -217,11 +302,10 @@ async function bootHandoffOwner(serializedContext,sessionId,sessionState: checkpoint.sessionState,+ sessionTimeoutControl: timeoutControl,sessionTimeoutMs: checkpoint.sessionTimeoutMs,// A deployment handoff renews the configured lifetime; compaction keeps the deadline.- sessionTimeoutDeadline: compaction- ? input.sessionTimeoutDeadline- : sessionTimeoutDeadline(checkpoint.sessionTimeoutMs, Date.now()),+ sessionTimeoutDeadline: deadline,sessionWritable: input.sessionWritable,},};diff --git a/packages/eve/src/execution/session/program.ts b/packages/eve/src/execution/session/program.tsindex 0e57a091f..72444bb05 100644--- a/packages/eve/src/execution/session/program.ts+++ b/packages/eve/src/execution/session/program.ts@@ -10,6 +10,7 @@ import type { HarnessModelMessage } from "#harness/messages.js";import { nextTurnDelivery, type NextTurnInstruction } from "#execution/session/next-input.js";import { SessionInputQueue } from "#execution/session/input-queue.js";import { SessionExecution } from "#execution/session/turn.js";+import { createTurnControl, type TurnControl } from "#execution/session/turn-control.js";import { SessionStateCursor } from "#execution/session/state-cursor.js";import { cancelWorkingTasks, sessionTaskTable } from "#execution/tasks/session.js";import { workingTasks } from "#execution/tasks/table.js";@@ -17,7 +18,7 @@ import type { TurnOutcome, TurnStepPayload } from "#execution/session/turn-step-import { settleCancelledTurnStep } from "#execution/settle-cancelled-turn-step.js";import { finalizeSession, type SessionTerminalOutcome } from "#execution/session/finalization.js";import { type SessionInboxHandle } from "#execution/session-inbox/inbox.js";-import { createSessionTimeoutControl } from "#execution/session/timeout-control.js";+import type { SessionTimeoutControl } from "#execution/session/timeout-control.js";import {type CompactionHandoff,SessionHandoff,@@ -61,11 +62,13 @@ export interface SessionBoot {readonly capabilities?: SessionCapabilities;readonly deploymentId: string;readonly history: HarnessModelMessage[];+ readonly initialTurnControl?: TurnControl;readonly start: SessionStart;readonly retention?: AgentWorkflowRetentionDefinition;readonly serializedContext: Record<string, unknown>;readonly sessionId: string;readonly sessionState: DurableSessionState;+ readonly sessionTimeoutControl?: SessionTimeoutControl;readonly sessionTimeoutDeadline?: Date;readonly sessionTimeoutMs: number | false;readonly sessionWritable: WritableStream<Uint8Array>;@@ -212,13 +215,7 @@ async function runSessionLoop(queue,sessionId: boot.sessionId,});- const sessionTimeout =- boot.sessionTimeoutDeadline === undefined- ? undefined- : createSessionTimeoutControl({- deadline: boot.sessionTimeoutDeadline,- sessionId: boot.sessionId,- });+ const sessionTimeout = boot.sessionTimeoutControl;const nextParkedActivity = async (): Promise<Exclude<NextTurnInstruction, { kind: "workflow" | "cancel-working-tasks" }>@@ -242,14 +239,18 @@ async function runSessionLoop(}};+ let turnControl =+ boot.initialTurnControl ?? (boot.anchor.kind === "self" ? createTurnControl() : undefined);let turnIndex = 0;// Set when a turn compacts and kept until the session moves to a fresh run,// so this run's event log does not keep growing.let compactionHandoffDue = false;const runTurn = async (payload: TurnStepPayload | undefined): Promise<TurnOutcome> => {const caller = progress.caller;+ const control = turnControl;+ turnControl = undefined;progress.turnId = `turn_${String(turnIndex++)}`;- const outcome = await execution.runTurn(payload, { caller });+ const outcome = await execution.runTurn(payload, { caller, control });if (outcome.caller !== undefined) progress.caller = outcome.caller;if (outcome.compacted === true) compactionHandoffDue = true;return outcome;@@ -391,6 +392,7 @@ async function runSessionLoop(}}} finally {+ turnControl?.dispose();await sessionTimeout?.dispose();}}diff --git a/packages/eve/src/execution/session/timeout-control.test.ts b/packages/eve/src/execution/session/timeout-control.test.tsindex e300866be..1eda7d219 100644--- a/packages/eve/src/execution/session/timeout-control.test.ts+++ b/packages/eve/src/execution/session/timeout-control.test.ts@@ -39,6 +39,48 @@ describe("createSessionTimeoutControl", () => {});});+ it("shares in-progress startup across concurrent start calls", async () => {+ let resolveStartup!: (value: { runId: string }) => void;+ vi.mocked(startSessionTimeoutStep).mockReturnValue(+ new Promise((resolve) => {+ resolveStartup = resolve;+ }),+ );+ const control = createSessionTimeoutControl({+ deadline: new Date("2026-02-01T00:00:00.000Z"),+ sessionId: "wrun_1",+ });++ const first = control.start();+ const second = control.start();+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ resolveStartup({ runId: "timer-run" });+ await Promise.all([first, second]);++ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();+ });++ it("waits for in-progress startup before cancelling", async () => {+ let resolveStartup!: (value: { runId: string }) => void;+ vi.mocked(startSessionTimeoutStep).mockReturnValue(+ new Promise((resolve) => {+ resolveStartup = resolve;+ }),+ );+ const control = createSessionTimeoutControl({+ deadline: new Date("2026-02-01T00:00:00.000Z"),+ sessionId: "wrun_1",+ });++ const startup = control.start();+ const disposal = control.dispose();+ expect(cancelSessionTimeoutStep).not.toHaveBeenCalled();+ resolveStartup({ runId: "timer-run" });+ await Promise.all([startup, disposal]);++ expect(cancelSessionTimeoutStep).toHaveBeenCalledWith({ runId: "timer-run" });+ });+it("cancels the active timer when the session settles", async () => {vi.mocked(startSessionTimeoutStep).mockResolvedValue({ runId: "timer-run" });const control = createSessionTimeoutControl({@@ -63,9 +105,11 @@ describe("createSessionTimeoutControl", () => {sessionId: "wrun_1",});+ await expect(control.start()).rejects.toBe(failure);await expect(control.start()).rejects.toBe(failure);await control.dispose();+ expect(startSessionTimeoutStep).toHaveBeenCalledOnce();expect(cancelSessionTimeoutStep).not.toHaveBeenCalled();});});diff --git a/packages/eve/src/execution/session/timeout-control.ts b/packages/eve/src/execution/session/timeout-control.tsindex 11d2b0fad..734d88012 100644--- a/packages/eve/src/execution/session/timeout-control.ts+++ b/packages/eve/src/execution/session/timeout-control.ts@@ -7,7 +7,7 @@ import {import { sessionCommandHookToken } from "#execution/session-inbox/address.js";/** Workflow-body handle that targets a durable deadline at the stable command inbox. */-interface SessionTimeoutControl {+export interface SessionTimeoutControl {dispose(): Promise<void>;start(): Promise<void>;}@@ -18,9 +18,15 @@ export function createSessionTimeoutControl(input: {readonly sessionId: string;}): SessionTimeoutControl {let active: { readonly runId: string } | undefined;+ let startup: Promise<void> | undefined;return {async dispose(): Promise<void> {+ try {+ await startup;+ } catch {+ // A failed startup has no child run to cancel.+ }if (active === undefined) return;const current = active;active = undefined;@@ -28,12 +34,14 @@ export function createSessionTimeoutControl(input: {},async start(): Promise<void> {- if (active !== undefined) return;- active = await startSessionTimeoutStep({- deadline: input.deadline,- ownerRunId: getWorkflowMetadata().workflowRunId,- token: sessionCommandHookToken(input.sessionId),- });+ startup ??= (async () => {+ active = await startSessionTimeoutStep({+ deadline: input.deadline,+ ownerRunId: getWorkflowMetadata().workflowRunId,+ token: sessionCommandHookToken(input.sessionId),+ });+ })();+ await startup;},};}diff --git a/packages/eve/src/execution/session/turn-control.test.ts b/packages/eve/src/execution/session/turn-control.test.tsnew file mode 100644index 000000000..11b5ac7a6--- /dev/null+++ b/packages/eve/src/execution/session/turn-control.test.ts@@ -0,0 +1,35 @@+import { afterEach, describe, expect, it, vi } from "vitest";++import { createTurnControl } from "#execution/session/turn-control.js";++afterEach(() => vi.unstubAllGlobals());++describe("createTurnControl", () => {+ it("constructs cancellation and steering controllers eagerly", () => {+ const NativeAbortController = AbortController;+ const construct = vi.fn(() => new NativeAbortController());+ vi.stubGlobal(+ "AbortController",+ class {+ constructor() {+ return construct();+ }+ },+ );++ const control = createTurnControl();++ expect(construct).toHaveBeenCalledTimes(2);+ expect(control.cancellation).not.toBe(control.steering);+ });++ it("retires both unused controls", () => {+ const control = createTurnControl();++ control.dispose();+ control.dispose();++ expect(control.cancellation.signal.aborted).toBe(true);+ expect(control.steering.signal.aborted).toBe(true);+ });+});diff --git a/packages/eve/src/execution/session/turn-control.ts b/packages/eve/src/execution/session/turn-control.tsnew file mode 100644index 000000000..654c6daac--- /dev/null+++ b/packages/eve/src/execution/session/turn-control.ts@@ -0,0 +1,19 @@+/** Workflow-owned abort controls prepared before a turn begins. */+export interface TurnControl {+ readonly cancellation: AbortController;+ readonly steering: AbortController;+ dispose(): void;+}++export function createTurnControl(): TurnControl {+ const cancellation = new AbortController();+ const steering = new AbortController();+ return {+ cancellation,+ steering,+ dispose() {+ cancellation.abort();+ steering.abort();+ },+ };+}diff --git a/packages/eve/src/execution/session/turn.test.ts b/packages/eve/src/execution/session/turn.test.tsindex 700a6e937..85b59012b 100644--- a/packages/eve/src/execution/session/turn.test.ts+++ b/packages/eve/src/execution/session/turn.test.ts@@ -4,6 +4,7 @@ import type { DurableSessionState } from "#execution/durable-session-store.js";import type { SessionInbox, SessionInboxPayload } from "#execution/session-inbox/inbox.js";import { SessionInputQueue } from "#execution/session/input-queue.js";import { SessionExecution } from "#execution/session/turn.js";+import { createTurnControl } from "#execution/session/turn-control.js";import { SessionStateCursor } from "#execution/session/state-cursor.js";import { cancelDescendantTurnsStep } from "#execution/cancel-descendant-turns-step.js";import { turnStep } from "#execution/session/turn-step.js";@@ -105,6 +106,29 @@ const dispatchWork = stepWork<const routeWork = stepWork<Parameters<typeof routeDeliverToChildren>[0], RoutedDeliverResult>;describe("SessionExecution checkpoints", () => {+ it("uses prepared cancellation and steering controls for the first step", async () => {+ const control = createTurnControl();+ vi.mocked(turnStep)+ .mockReset()+ .mockImplementationOnce(+ turnStepWork(async (input) => {+ expect(input.abortSignal).toBe(control.cancellation.signal);+ expect(input.steeringSignal).toBe(control.steering.signal);+ return {+ action: "done",+ serializedContext: input.serializedContext,+ sessionState: input.sessionState,+ };+ }),+ );++ await createExecution({ inbox: idleInbox(), sessionState: state("") }).runTurn(undefined, {+ control,+ });++ expect(turnStep).toHaveBeenCalledOnce();+ });+it("retains the durable steering signal across steps until a correction uses it", async () => {const inbox = idleInbox();let signal: AbortSignal | undefined;diff --git a/packages/eve/src/execution/session/turn.ts b/packages/eve/src/execution/session/turn.tsindex 9d6cd8346..f404ddbc4 100644--- a/packages/eve/src/execution/session/turn.ts+++ b/packages/eve/src/execution/session/turn.ts@@ -38,6 +38,7 @@ import type {} from "#execution/session/turn-step-types.js";import { turnStep } from "#execution/session/turn-step.js";import { ActiveTurn } from "#execution/session/active-turn.js";+import type { TurnControl } from "#execution/session/turn-control.js";import {findBlockingWorkflowToolRun,getBlockingWorkflowToolRuns,@@ -96,12 +97,23 @@ export class SessionExecution {* input carries no caller. The turn's first step binds it into the context.*/readonly caller?: TurnCaller;+ readonly control?: TurnControl;} = {},): Promise<TurnOutcome> {- const turn = new ActiveTurn(this.input, {- caller: options.caller,- principal: resolveTurnPrincipal(delivery, this.input.cursor.serializedContext),- });+ let turn: ActiveTurn;+ try {+ turn = new ActiveTurn(+ this.input,+ {+ caller: options.caller,+ principal: resolveTurnPrincipal(delivery, this.input.cursor.serializedContext),+ },+ options.control,+ );+ } catch (error) {+ options.control?.dispose();+ throw error;+ }try {const outcome = await this.runTurnSteps(turn, delivery);// Tasks run beside the turn, and a run can open a session after its call