Skip to content

armgit / eve

Public Imported from GitHub
0

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.md
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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