@cursor/bdk 0.2.11 → 0.2.13

package/dist/internal/session-engine.js

@@ -53,14 +53,17 @@ import { sessionExternalLinks } from "./session-links.js";
 import { SessionStore } from "./session-store.js";
 import { syncSkillsToStore } from "./skills-sync.js";
 import { steeringEnabled } from "./steering.js";
+import { resolveApiKeySync } from "./cursor/credentials.js";
+import { createSessionLivePublisher } from "./session-live-publisher.js";
 import { StorageCoordinator, isTurnBoundaryEvent } from "./storage-coordinator.js";
 import { decideToolCall, directCallEffect } from "./tool-policy.js";
+import { retryReadOnlyToolCall } from "./tool-call-retry.js";
 import { normalizeToolResult, toolCallErrorMessage } from "./tool-result.js";
 import { estimateTurnCostFromApi, roundCostUsd, } from "./turn-cost.js";
 import { TurnGovernor } from "./turn-governor.js";
 import { TurnLeaseStore } from "./turn-lease-store.js";
 import { TurnOutbox } from "./turn-outbox.js";
-import { resolveAgentV2Hosting } from "./v2-hosting.js";
+import { isCursorManagedV2Hosting, resolveAgentV2Hosting } from "./v2-hosting.js";
 import { buildAgentsMdContent, buildCloudMemorySection, buildCloudSessionWorkspaceSection, buildCloudWorkspaceSection, ensureOwnGitRoot, isNestedInGitRepo, materializeWorkspace, SERVER_TOOLS_MCP_SERVER_NAME, } from "./workspace.js";
 import { syncSessionWorkspaceFiles, syncWorkspaceToStore, WorkspaceFileRefusal, wipeSessionWorkspace, } from "./workspace-sync.js";
 export const HTTP_CHANNEL_ID = "http";
@@ -274,7 +277,7 @@ export class SessionEngine {
         this.askDedupe = new SlackAskDedupeStore(join(options.stateRoot, "slack-asks"));
         this.turnLeases = new TurnLeaseStore(join(options.stateRoot, "turn-leases"));
         this.outbox = new TurnOutbox(join(options.stateRoot, "outbox"));
-        this.logs = new EventLogStore(sessionId => this.sessions.eventFilePath(sessionId), (sessionId, error) => this.logger(`[bdk] failed to persist events for ${sessionId}: ${describeError(error)}`));
+        this.logs = new EventLogStore((sessionId) => this.sessions.eventFilePath(sessionId), (sessionId, error) => this.logger(`[bdk] failed to persist events for ${sessionId}: ${describeError(error)}`));
         // Framework session state (records, event chunks, continuations) is
         // mirrored to whatever this selects; see framework-storage-selection.ts
         // for why the choice does not belong to the agent author.
@@ -292,14 +295,24 @@ export class SessionEngine {
                     logger: this.logger,
                     keys: storageKeysForArchitecture(options.project.agent.architecture),
                 });
+        const v2Hosting = resolveAgentV2Hosting({
+            architecture: options.project.agent.architecture,
+        });
+        // Author KV stays on disk for a persistent slot: `/state/kv` is durable
+        // and already holds entries a switch to the store would hide.
+        const authorKvStorage = v2Hosting.kind === "cursor-managed-persistent" ? undefined : this.storage;
         this.kvApi = createHostKvApi({
             agentName: options.project.name,
             stateRoot: options.stateRoot,
-            ...(this.storage === undefined ? {} : { storage: this.storage }),
-        });
-        const v2Hosting = resolveAgentV2Hosting({
-            architecture: options.project.agent.architecture,
+            ...(authorKvStorage === undefined ? {} : { storage: authorKvStorage }),
         });
+        this.livePublisher = isCursorManagedV2Hosting(v2Hosting)
+            ? createSessionLivePublisher({
+                readEvents: (sessionId, fromIndex) => this.listEvents(sessionId, fromIndex),
+                resolveApiKey: () => resolveApiKeySync()?.apiKey,
+                logger: this.logger,
+            })
+            : undefined;
         const managedV2Files = v2Hosting.kind === "cursor-managed"
             ? () => cursorHostedFiles({
                 resolveStoreSourceId: () => v2Hosting.resolveStoreIds().deploymentStoreSourceId,
@@ -332,7 +345,7 @@ export class SessionEngine {
         this.mcpHost = new McpHost([
             ...options.project.agent.connections,
             ...(options.project.agent.hostConnections ?? []),
-        ].filter(connection => !isSymbolicConnectionTransport(connection.transport)));
+        ].filter((connection) => !isSymbolicConnectionTransport(connection.transport)));
         const basePlatforms = options.platforms ?? createHostPlatforms();
         const slackBinding = resolveDedicatedSlackHostBinding(options.project.channels);
         this.platforms =
@@ -378,8 +391,8 @@ export class SessionEngine {
         }
     }
     authoredConnection(name) {
-        return (this.project.agent.connections.find(item => item.name === name) ??
-            this.project.agent.hostConnections?.find(item => item.name === name));
+        return (this.project.agent.connections.find((item) => item.name === name) ??
+            this.project.agent.hostConnections?.find((item) => item.name === name));
     }
     setCloudServerToolsConnection(connection, resolveHeaders) {
         this.cloudServerToolsConnection = connection;
@@ -464,8 +477,8 @@ export class SessionEngine {
                     turnId: input.turnId ?? binding.turnId,
                 });
             },
-            list: filter => this.artifactsStore.list(filter),
-            page: options => this.artifactsStore.page(options),
+            list: (filter) => this.artifactsStore.list(filter),
+            page: (options) => this.artifactsStore.page(options),
         };
     }
     /**
@@ -592,10 +605,10 @@ export class SessionEngine {
     }
     slackNudgeHostApi() {
         return {
-            append: input => this.nudgeStore.append(input),
-            drainFormatted: continuationKey => this.nudgeStore.drainFormatted(continuationKey),
-            clear: continuationKey => this.nudgeStore.clear(continuationKey),
-            hasUndelivered: continuationKey => this.nudgeStore.hasUndelivered(continuationKey),
+            append: (input) => this.nudgeStore.append(input),
+            drainFormatted: (continuationKey) => this.nudgeStore.drainFormatted(continuationKey),
+            clear: (continuationKey) => this.nudgeStore.clear(continuationKey),
+            hasUndelivered: (continuationKey) => this.nudgeStore.hasUndelivered(continuationKey),
             isDelivered: (continuationKey, sourceTs) => this.nudgeStore.isDelivered(continuationKey, sourceTs),
             tryClaimAsk: (channelId, messageTs) => this.askDedupe.tryClaim(channelId, messageTs),
             releaseAsk: (channelId, messageTs) => this.askDedupe.release(channelId, messageTs),
@@ -686,7 +699,7 @@ export class SessionEngine {
                 if (refreshWorkspace ||
                     sendOptions.workspaceFiles !== undefined ||
                     sendOptions.images !== undefined) {
-                    record = await this.updateRecord(existing.sessionId, current => ({
+                    record = await this.updateRecord(existing.sessionId, (current) => ({
                         ...current,
                         workspaceOverride: refreshWorkspace
                             ? sendOptions.workspaceDir
@@ -699,14 +712,14 @@ export class SessionEngine {
                 // configured runtime. Omission remains sticky for compatibility:
                 // follow-ups that do not know the original attach keep it.
                 if (sendOptions.clearCloudOverride === true && record.cloudOverride !== undefined) {
-                    record = await this.updateRecord(record.sessionId, current => ({
+                    record = await this.updateRecord(record.sessionId, (current) => ({
                         ...current,
                         cloudOverride: undefined,
                     }));
                 }
                 else if (sendOptions.cloud !== undefined &&
                     JSON.stringify(sendOptions.cloud) !== JSON.stringify(record.cloudOverride)) {
-                    record = await this.updateRecord(record.sessionId, current => ({
+                    record = await this.updateRecord(record.sessionId, (current) => ({
                         ...current,
                         cloudOverride: sendOptions.cloud,
                     }));
@@ -714,7 +727,7 @@ export class SessionEngine {
                 // Refresh wake-derived channel state (GitHub headSha / refs) without
                 // wiping sticky fields. Null patch values are skipped.
                 if (sendOptions.refreshState !== undefined) {
-                    record = await this.updateRecord(record.sessionId, current => ({
+                    record = await this.updateRecord(record.sessionId, (current) => ({
                         ...current,
                         channelState: mergeChannelStateSkipNull(current.channelState, sendOptions.refreshState),
                     }));
@@ -791,7 +804,7 @@ export class SessionEngine {
         const stale = new Error("stale HTTP continuation");
         let previous;
         try {
-            await this.updateRecord(sessionId, record => {
+            await this.updateRecord(sessionId, (record) => {
                 const expectedChannel = record.httpContinuationKey === undefined ? record.channelId : HTTP_CHANNEL_ID;
                 const expectedKey = record.httpContinuationKey ?? record.continuationKey;
                 if (token.channelId !== expectedChannel || token.key !== expectedKey) {
@@ -812,7 +825,7 @@ export class SessionEngine {
             return next;
         }
         catch (error) {
-            await this.updateRecord(sessionId, record => record.httpContinuationKey === next ? { ...record, httpContinuationKey: previous } : record);
+            await this.updateRecord(sessionId, (record) => record.httpContinuationKey === next ? { ...record, httpContinuationKey: previous } : record);
             throw error;
         }
     }
@@ -939,7 +952,7 @@ export class SessionEngine {
     drainOutbox(sessionId) {
         void this.outbox
             .takeAll(sessionId)
-            .then(items => {
+            .then((items) => {
             for (const item of items) {
                 void this.startTurn(sessionId, item.message, item.options).catch(() => { });
             }
@@ -948,7 +961,7 @@ export class SessionEngine {
     }
     enqueueCoalesced(sessionId, item) {
         const queue = this.coalesceQueues.get(sessionId) ?? [];
-        if (item.sourceTs !== undefined && queue.some(entry => entry.sourceTs === item.sourceTs)) {
+        if (item.sourceTs !== undefined && queue.some((entry) => entry.sourceTs === item.sourceTs)) {
             return;
         }
         queue.push(item);
@@ -1124,7 +1137,7 @@ export class SessionEngine {
         this.pendingTurns.add(sessionId);
         let lifecycleInstalled = false;
         try {
-            const record = await this.updateRecord(sessionId, current => ({
+            const record = await this.updateRecord(sessionId, (current) => ({
                 ...current,
                 turnCount: current.turnCount + 1,
             }));
@@ -1175,7 +1188,7 @@ export class SessionEngine {
                 // Failed or cancelled owners must not start a coalesced successor;
                 // managed delivery retries the same follow-ups.
                 if (wasCurrent && !abort.signal.aborted && outcome.status === "finished") {
-                    const drain = this.drainCoalescedFollowups(sessionId).catch(error => {
+                    const drain = this.drainCoalescedFollowups(sessionId).catch((error) => {
                         this.logger(`[session] coalesce drain failed for ${sessionId}: ${describeError(error)}`);
                     });
                     this.coalesceDrains.set(sessionId, drain);
@@ -1391,7 +1404,7 @@ export class SessionEngine {
         if (turn === undefined) {
             return tools;
         }
-        return tools.map(tool => {
+        return tools.map((tool) => {
             const execute = tool.definition.execute;
             if (typeof execute !== "function") {
                 return tool;
@@ -1586,7 +1599,7 @@ export class SessionEngine {
                 // the turns' requests or the warmed executor is one no turn asks for.
                 mcpServers: this.buildMcpServers("local"),
                 ...(this.hasAttachedAuthedConnections() ||
-                    this.project.agent.connections.some(connection => isCursorAccountTransport(connection.transport))
+                    this.project.agent.connections.some((connection) => isCursorAccountTransport(connection.transport))
                     ? { perSendMcpServers: true }
                     : {}),
                 subagents: buildRunnerSubagents(agent),
@@ -1637,7 +1650,7 @@ export class SessionEngine {
         // Read by closure, so the mapper still sees it while draining after the
         // registry entry below is gone.
         const stubbed = new Set();
-        const mapper = new TurnEventMapper(emit, callId => stubbed.has(callId));
+        const mapper = new TurnEventMapper(emit, (callId) => stubbed.has(callId));
         // Take a turn slot before any work happens. When every slot is busy the
         // turn waits FIFO — durable `turn.queued` marks the wait — and a
         // preempting follow-up (or interrupt) resolves the wait as cancelled
@@ -1645,7 +1658,7 @@ export class SessionEngine {
         const permit = await this.turnGovernor.acquire({
             sessionId,
             signal,
-            onQueued: position => {
+            onQueued: (position) => {
                 const maxRunningTurns = this.turnGovernor.maxRunningTurns ?? 0;
                 emit({ type: "turn.queued", data: { position, maxRunningTurns } });
                 this.logger(`[session] ${sessionId} ${turnId} queued at position ${position} (${maxRunningTurns} turn slot(s) busy)`);
@@ -1704,7 +1717,7 @@ export class SessionEngine {
                 }
                 if ((hasPendingFiles && runtime !== "cloud") ||
                     (pendingImages !== undefined && pendingImages.length > 0)) {
-                    await this.updateRecord(sessionId, current => ({
+                    await this.updateRecord(sessionId, (current) => ({
                         ...current,
                         pendingWorkspaceFiles: hasPendingFiles &&
                             runtime !== "cloud" &&
@@ -1772,7 +1785,7 @@ export class SessionEngine {
         mapper.finish();
         if (mapper.title !== undefined) {
             const title = mapper.title;
-            await this.updateRecord(sessionId, current => ({ ...current, title }));
+            await this.updateRecord(sessionId, (current) => ({ ...current, title }));
             eventContext.session = { ...eventContext.session, title };
         }
         const finalResult = outcome.result ?? mapper.finalText;
@@ -1832,7 +1845,7 @@ export class SessionEngine {
         // dispatch, and awaiting that chain deadlocks when an earlier handler
         // is waiting on the next turn (defineResult refresh). Coalesce drain
         // snapshots disk as soon as this returns.
-        await this.updateRecord(sessionId, current => ({
+        await this.updateRecord(sessionId, (current) => ({
             ...current,
             channelState: mergeChannelStateMutation({
                 current: current.channelState,
@@ -1912,7 +1925,7 @@ export class SessionEngine {
         }
     }
     async clearPendingWorkspaceFiles(sessionId, pending) {
-        await this.updateRecord(sessionId, current => ({
+        await this.updateRecord(sessionId, (current) => ({
             ...current,
             pendingWorkspaceFiles: current.pendingWorkspaceFiles === pending ? undefined : current.pendingWorkspaceFiles,
         }));
@@ -1929,7 +1942,7 @@ export class SessionEngine {
         if (inFlight !== undefined) {
             return inFlight;
         }
-        let sync = run().then(() => true, error => {
+        let sync = run().then(() => true, (error) => {
             this.logger(`[${surface}] ${store.label} sync failed: ${error instanceof Error ? error.message : String(error)}`);
             return false;
         });
@@ -2016,7 +2029,7 @@ export class SessionEngine {
         // per-session tools or identity is worse than a refused one. Non-local
         // agents already fail discovery; this guards hybrid agents' per-send
         // cloud sessions.
-        const perSessionConnection = agent.connections.find(connection => connection.advertiseTools === true || connection.auth !== undefined);
+        const perSessionConnection = agent.connections.find((connection) => connection.advertiseTools === true || connection.auth !== undefined);
         if (runtime !== "local" && perSessionConnection !== undefined) {
             throw new Error(`Agent "${agent.name}" connection "${perSessionConnection.name}" uses advertiseTools/auth, which only run on local turns. Refusing the session rather than running it without the connection's tools or identity.`);
         }
@@ -2055,7 +2068,7 @@ export class SessionEngine {
         // replace a working index with an empty custom tool.
         const synthesized = root === undefined
             ? []
-            : this.withTurnScratchTools(authoredRoot ? fileTools : fileTools.filter(tool => tool.name !== "SemanticSearch"), record.sessionId);
+            : this.withTurnScratchTools(authoredRoot ? fileTools : fileTools.filter((tool) => tool.name !== "SemanticSearch"), record.sessionId);
         let turnPrompt = prompt;
         if (isFirstTurn) {
             const contextBlock = buildSessionContextBlock({
@@ -2120,7 +2133,7 @@ export class SessionEngine {
                 sections.push(buildCloudMemorySection(this.project.name));
             }
             if (preamble !== "" || sections.length > 0) {
-                turnPrompt = [preamble, ...sections, turnPrompt].filter(part => part !== "").join("\n\n");
+                turnPrompt = [preamble, ...sections, turnPrompt].filter((part) => part !== "").join("\n\n");
             }
         }
         else if (isFirstTurn && runtime === "local" && authoredRoot) {
@@ -2172,11 +2185,13 @@ export class SessionEngine {
             ...(runtime === "cloud" && !isCursorHostedFilesAvailable()
                 ? { agentServeAgent: this.project.name }
                 : {}),
-            customTools: runtime === "local" ? await this.buildCustomTools(record, turnId, emit, synthesized) : {},
+            customTools: runtime === "local"
+                ? await this.buildCustomTools(record, turnId, emit, synthesized, signal)
+                : {},
             mcpServers: this.buildMcpServers(runtime, record.sessionId, await this.evaluateConnectionAuth(record)),
             ...(runtime === "local" &&
                 (this.hasAttachedAuthedConnections() ||
-                    this.project.agent.connections.some(connection => isCursorAccountTransport(connection.transport)))
+                    this.project.agent.connections.some((connection) => isCursorAccountTransport(connection.transport)))
                 ? { perSendMcpServers: true }
                 : {}),
             subagents: buildRunnerSubagents(agent),
@@ -2185,14 +2200,14 @@ export class SessionEngine {
             // Local follow-ups expire any lingering active run so a preempted turn
             // (or one orphaned by a crashed process) never blocks this send.
             forceExpireActiveRun: runtime === "local" && !isFirstTurn,
-            onRequestId: requestId => {
+            onRequestId: (requestId) => {
                 emit({ type: "turn.bound", data: { requestId } });
             },
             onSdkAgentId: async (sdkAgentId) => {
                 if (record.sdkAgentId === sdkAgentId) {
                     return;
                 }
-                await this.updateRecord(record.sessionId, current => ({
+                await this.updateRecord(record.sessionId, (current) => ({
                     ...current,
                     sdkAgentId,
                 }));
@@ -2275,9 +2290,9 @@ export class SessionEngine {
         // Advertised connections surface as named server tools instead of an
         // attached MCP server (each tool appears exactly once).
         const advertisedNames = new Set(this.project.agent.connections
-            .filter(connection => connection.advertiseTools === true)
-            .map(connection => connection.name));
-        const hostConnectionNames = new Set((this.project.agent.hostConnections ?? []).map(connection => connection.name));
+            .filter((connection) => connection.advertiseTools === true)
+            .map((connection) => connection.name));
+        const hostConnectionNames = new Set((this.project.agent.hostConnections ?? []).map((connection) => connection.name));
         const bridgedNames = new Set(runtime === "cloud" &&
             sessionId !== undefined &&
             this.cloudServerToolsConnection !== undefined &&
@@ -2286,7 +2301,7 @@ export class SessionEngine {
             : []);
         assertCloudCanHonorAccountServersFilters({
             runtime,
-            resolvedConnections: this.resolvedConnections.filter(resolved => !advertisedNames.has(resolved.name) && !hostConnectionNames.has(resolved.name)),
+            resolvedConnections: this.resolvedConnections.filter((resolved) => !advertisedNames.has(resolved.name) && !hostConnectionNames.has(resolved.name)),
             bridgedNames,
         });
         const bridgeTransport = (name) => sessionId === undefined || !bridgedNames.has(name)
@@ -2368,7 +2383,7 @@ export class SessionEngine {
         if (runtime === "cloud" &&
             sessionId !== undefined &&
             this.cloudServerToolsConnection !== undefined &&
-            this.project.agent.tools.some(tool => tool.execution === "server")) {
+            this.project.agent.tools.some((tool) => tool.execution === "server")) {
             if (servers[SERVER_TOOLS_MCP_SERVER_NAME] !== undefined) {
                 throw new Error(`MCP connection name "${SERVER_TOOLS_MCP_SERVER_NAME}" is reserved for authored server tools on cloud turns.`);
             }
@@ -2391,7 +2406,7 @@ export class SessionEngine {
      * ride every send instead of being pinned on the cached agent handle.
      */
     hasAttachedAuthedConnections() {
-        return this.project.agent.connections.some(connection => connection.auth !== undefined && connection.advertiseTools !== true);
+        return this.project.agent.connections.some((connection) => connection.auth !== undefined && connection.advertiseTools !== true);
     }
     /**
      * Evaluate per-session connection auth (`defineConnection({ auth })`)
@@ -2401,7 +2416,7 @@ export class SessionEngine {
      * without the connection's identity.
      */
     async evaluateConnectionAuth(record) {
-        const authed = this.project.agent.connections.filter(connection => connection.auth !== undefined && connection.advertiseTools !== true);
+        const authed = this.project.agent.connections.filter((connection) => connection.auth !== undefined && connection.advertiseTools !== true);
         if (authed.length === 0) {
             return undefined;
         }
@@ -2423,7 +2438,7 @@ export class SessionEngine {
         }
         return evaluated;
     }
-    async buildCustomTools(record, turnId, emit, extraTools = []) {
+    async buildCustomTools(record, turnId, emit, extraTools = [], signal) {
         const agent = this.project.agent;
         const tools = {};
         const register = (tool) => {
@@ -2447,6 +2462,7 @@ export class SessionEngine {
                         record,
                         turnId,
                         emit,
+                        signal,
                     });
                 },
             };
@@ -2494,7 +2510,7 @@ export class SessionEngine {
         if (active === undefined) {
             return toolErrorResult(`Session ${sessionId} has no active turn for tool "${toolName}".`);
         }
-        const tool = this.project.agent.tools.find(candidate => candidate.name === toolName && candidate.execution === "server");
+        const tool = this.project.agent.tools.find((candidate) => candidate.name === toolName && candidate.execution === "server");
         if (tool === undefined) {
             return toolErrorResult(`Unknown server tool "${toolName}".`);
         }
@@ -2507,6 +2523,7 @@ export class SessionEngine {
             record: active.record,
             turnId: active.turnId,
             emit: active.emit,
+            signal: this.turnAborts.get(sessionId)?.signal,
         });
         this.logger(`[session] cloud HTTP MCP tool ${toolName} complete (${sessionId}, ${toolCallId}, isError=${isErrorEnvelope(result)})`);
         return result;
@@ -2607,7 +2624,14 @@ export class SessionEngine {
                 callId: toolCallId,
                 toolName: args.tool.name,
                 emit: args.emit,
-            }, () => execute(validation.value, toolCtx)));
+            }, () => this.runExecutedTool({
+                tool: args.tool,
+                input: validation.value,
+                callId: toolCallId,
+                signal: args.signal,
+                emit: args.emit,
+                execute: () => execute(validation.value, toolCtx),
+            })));
             this.logger(`[session] tool ${args.tool.name} done (${Date.now() - started}ms)`);
             return normalizeToolResult(result);
         }
@@ -2651,6 +2675,34 @@ export class SessionEngine {
             toolName: args.toolName,
         }, run);
     }
+    /**
+     * Retry a read-effect call that already passed validation, dry-run, and
+     * approval. Anything else runs once; a transient failure there is counted
+     * and rethrown unchanged.
+     */
+    runExecutedTool(args) {
+        const connection = args.tool.connection;
+        return retryReadOnlyToolCall({
+            toolName: args.tool.name,
+            ...(connection === undefined ? {} : { connection }),
+            effect: directCallEffect(args.tool, args.input),
+            signal: args.signal,
+            onRetry: (notice) => {
+                this.logger(`[session] tool ${args.tool.name} retry connection=${notice.connection ?? "-"} attempt=${notice.attempt} class=${notice.reason} backoffMs=${notice.backoffMs}`);
+                args.emit?.({
+                    type: "action.tool_retry",
+                    data: {
+                        callId: args.callId,
+                        toolName: args.tool.name,
+                        attempt: notice.attempt,
+                        reason: notice.reason,
+                        ...(notice.connection === undefined ? {} : { connection: notice.connection }),
+                    },
+                });
+            },
+            execute: args.execute,
+        });
+    }
     /**
      * Park a server-tool call until a human approves or denies. Emits
      * `action.approval_requested` / `action.approval_resolved` on the
@@ -2666,10 +2718,10 @@ export class SessionEngine {
             requestedAt,
         };
         const resolutionPromise = this.approvals.wait(args.sessionId, pendingRecord);
-        await this.updateRecord(args.sessionId, current => ({
+        await this.updateRecord(args.sessionId, (current) => ({
             ...current,
             pendingApprovals: [
-                ...(current.pendingApprovals ?? []).filter(item => item.callId !== args.callId),
+                ...(current.pendingApprovals ?? []).filter((item) => item.callId !== args.callId),
                 pendingRecord,
             ],
         }));
@@ -2683,9 +2735,9 @@ export class SessionEngine {
         });
         this.logger(`[session] tool ${args.toolName} awaiting approval (${args.callId})`);
         const { decision, by } = await resolutionPromise;
-        await this.updateRecord(args.sessionId, current => ({
+        await this.updateRecord(args.sessionId, (current) => ({
             ...current,
-            pendingApprovals: (current.pendingApprovals ?? []).filter(item => item.callId !== args.callId),
+            pendingApprovals: (current.pendingApprovals ?? []).filter((item) => item.callId !== args.callId),
         }));
         args.emit({
             type: "action.approval_resolved",
@@ -2706,7 +2758,7 @@ export class SessionEngine {
             current.pendingApprovals.length === 0) {
             return;
         }
-        await this.updateRecord(sessionId, record => ({
+        await this.updateRecord(sessionId, (record) => ({
             ...record,
             pendingApprovals: [],
         }));
@@ -2740,8 +2792,8 @@ export class SessionEngine {
         if (!samePrincipal(record.auth, ownershipAuth)) {
             throw new SessionAuthError(sessionId);
         }
-        const pending = (record.pendingApprovals ?? []).find(item => item.callId === callId) ??
-            this.approvals.list(sessionId).find(item => item.callId === callId);
+        const pending = (record.pendingApprovals ?? []).find((item) => item.callId === callId) ??
+            this.approvals.list(sessionId).find((item) => item.callId === callId);
         if (pending === undefined) {
             throw new ApprovalNotFoundError(sessionId, callId);
         }
@@ -2753,23 +2805,23 @@ export class SessionEngine {
         return pending;
     }
     async removePendingApproval(sessionId, callId) {
-        await this.updateRecord(sessionId, current => ({
+        await this.updateRecord(sessionId, (current) => ({
             ...current,
-            pendingApprovals: (current.pendingApprovals ?? []).filter(item => item.callId !== callId),
+            pendingApprovals: (current.pendingApprovals ?? []).filter((item) => item.callId !== callId),
         }));
     }
     wrapMcp(inner) {
         return {
             names: () => inner.names(),
-            listTools: name => this.withMcpAuth(name, () => inner.listTools(name)),
+            listTools: (name) => this.withMcpAuth(name, () => inner.listTools(name)),
             callTool: (name, tool, args) => this.withMcpAuth(name, () => inner.callTool(name, tool, args)),
         };
     }
     advertiseMcp() {
         return {
-            listTools: name => this.withMcpListAuth(name, () => this.mcpHost.listTools(name)),
+            listTools: (name) => this.withMcpListAuth(name, () => this.mcpHost.listTools(name)),
             callTool: (name, tool, args) => this.withMcpAuth(name, () => this.mcpHost.callTool(name, tool, args)),
-            oneOff: connection => {
+            oneOff: (connection) => {
                 const inner = this.mcpHost.oneOff(connection);
                 return {
                     listTools: () => this.withMcpListAuth(connection.name, () => inner.listTools()),
@@ -2885,10 +2937,10 @@ export class SessionEngine {
             requestedAt,
         };
         const resolutionPromise = this.auths.wait(args.sessionId, pendingRecord);
-        await this.updateRecord(args.sessionId, current => ({
+        await this.updateRecord(args.sessionId, (current) => ({
             ...current,
             pendingAuths: [
-                ...(current.pendingAuths ?? []).filter(item => item.callId !== args.callId),
+                ...(current.pendingAuths ?? []).filter((item) => item.callId !== args.callId),
                 pendingRecord,
             ],
         }));
@@ -2903,9 +2955,9 @@ export class SessionEngine {
         });
         this.logger(`[session] tool ${args.toolName} awaiting MCP auth ${args.connection} (${args.callId})`);
         const { decision, by } = await resolutionPromise;
-        await this.updateRecord(args.sessionId, current => ({
+        await this.updateRecord(args.sessionId, (current) => ({
             ...current,
-            pendingAuths: (current.pendingAuths ?? []).filter(item => item.callId !== args.callId),
+            pendingAuths: (current.pendingAuths ?? []).filter((item) => item.callId !== args.callId),
         }));
         args.emit({
             type: "action.auth_resolved",
@@ -2928,7 +2980,7 @@ export class SessionEngine {
             current.pendingAuths.length === 0) {
             return;
         }
-        await this.updateRecord(sessionId, record => ({
+        await this.updateRecord(sessionId, (record) => ({
             ...record,
             pendingAuths: [],
         }));
@@ -2953,8 +3005,8 @@ export class SessionEngine {
         if (!samePrincipal(record.auth, ownershipAuth)) {
             throw new SessionAuthError(sessionId);
         }
-        const pending = (record.pendingAuths ?? []).find(item => item.callId === callId) ??
-            this.auths.list(sessionId).find(item => item.callId === callId);
+        const pending = (record.pendingAuths ?? []).find((item) => item.callId === callId) ??
+            this.auths.list(sessionId).find((item) => item.callId === callId);
         if (pending === undefined) {
             throw new AuthNotFoundError(sessionId, callId);
         }
@@ -2969,9 +3021,9 @@ export class SessionEngine {
         return pending;
     }
     async removePendingAuth(sessionId, callId) {
-        await this.updateRecord(sessionId, current => ({
+        await this.updateRecord(sessionId, (current) => ({
             ...current,
-            pendingAuths: (current.pendingAuths ?? []).filter(item => item.callId !== callId),
+            pendingAuths: (current.pendingAuths ?? []).filter((item) => item.callId !== callId),
         }));
     }
     async runWithMcpPark(sessionId, toolName, fn) {
@@ -3113,16 +3165,16 @@ export class SessionEngine {
      * fetch for `ls` must not wait on every advertised MCP server.
      */
     async describeCatalogTool(toolName, options = {}) {
-        const authored = this.project.agent.tools.find(tool => tool.name === toolName);
+        const authored = this.project.agent.tools.find((tool) => tool.name === toolName);
         if (authored !== undefined) {
             return { tool: authored };
         }
         const catalog = await this.listCatalogTools(options);
-        const tool = catalog.tools.find(entry => entry.name === toolName);
+        const tool = catalog.tools.find((entry) => entry.name === toolName);
         if (tool === undefined) {
             return {
                 tool: undefined,
-                availableTools: catalog.tools.map(entry => entry.name),
+                availableTools: catalog.tools.map((entry) => entry.name),
                 connectionErrors: catalog.connectionErrors,
             };
         }
@@ -3156,8 +3208,9 @@ export class SessionEngine {
         if (native !== undefined) {
             return native;
         }
-        let tool = this.project.agent.tools.find(t => t.name === toolName);
-        if (tool === undefined && this.project.agent.connections.some(c => c.advertiseTools === true)) {
+        let tool = this.project.agent.tools.find((t) => t.name === toolName);
+        if (tool === undefined &&
+            this.project.agent.connections.some((c) => c.advertiseTools === true)) {
             // Advertised passthroughs are ordinary server tools in the session's
             // namespace; resolve the live listing so direct calls address them by
             // the same model-facing name a turn would. A listing failure fails
@@ -3167,10 +3220,10 @@ export class SessionEngine {
                 session,
                 hostMcp: this.advertiseMcp(),
             });
-            tool = advertised.find(t => t.name === toolName);
+            tool = advertised.find((t) => t.name === toolName);
         }
         if (tool === undefined) {
-            throw new UnknownToolError(toolName, this.project.agent.tools.filter(t => t.execution === "server").map(t => t.name));
+            throw new UnknownToolError(toolName, this.project.agent.tools.filter((t) => t.execution === "server").map((t) => t.name));
         }
         const execute = tool.definition.execute;
         if (tool.execution !== "server" || typeof execute !== "function") {
@@ -3310,27 +3363,34 @@ export class SessionEngine {
                 isError = false;
             }
             else {
-                const run = () => execute(validation.value, {
-                    toolCallId: callId,
-                    session,
-                    workspaceDir,
-                    stateRoot: this.stateRoot,
-                    host: this.hostForSession(record?.sessionId),
-                    // Scratch calls have no real session; their facade stays unbound.
-                    artifacts: record === undefined
-                        ? this.artifactsApi()
-                        : this.artifactsApi({
-                            sessionId: record.sessionId,
-                            turnId: callId,
+                const run = () => this.runExecutedTool({
+                    tool,
+                    input: validation.value,
+                    callId,
+                    signal: record === undefined ? undefined : this.turnAborts.get(record.sessionId)?.signal,
+                    emit,
+                    execute: () => execute(validation.value, {
+                        toolCallId: callId,
+                        session,
+                        workspaceDir,
+                        stateRoot: this.stateRoot,
+                        host: this.hostForSession(record?.sessionId),
+                        // Scratch calls have no real session; their facade stays unbound.
+                        artifacts: record === undefined
+                            ? this.artifactsApi()
+                            : this.artifactsApi({
+                                sessionId: record.sessionId,
+                                turnId: callId,
+                            }),
+                        send: (channelId, message, sendOptions = {}) => this.send(channelId, message, {
+                            ...sendOptions,
+                            auth: sendOptions.auth !== undefined ? sendOptions.auth : session.auth,
                         }),
-                    send: (channelId, message, sendOptions = {}) => this.send(channelId, message, {
-                        ...sendOptions,
-                        auth: sendOptions.auth !== undefined ? sendOptions.auth : session.auth,
+                        getSession: (channelId, sessionId) => this.getChannelSession(channelId, sessionId),
+                        emit,
+                        now: sessionClock(record?.asOf),
+                        ...(record?.asOf === undefined ? {} : { asOf: record.asOf }),
                     }),
-                    getSession: (channelId, sessionId) => this.getChannelSession(channelId, sessionId),
-                    emit,
-                    now: sessionClock(record?.asOf),
-                    ...(record?.asOf === undefined ? {} : { asOf: record.asOf }),
                 });
                 const executeBody = record !== undefined && emit !== undefined
                     ? () => mcpAuthAls.run({
@@ -3480,7 +3540,7 @@ export class SessionEngine {
     async bridgedToolInfo(connectionName, toolName) {
         try {
             const listed = await this.host.mcp.listTools(connectionName);
-            return listed.find(tool => tool.name === toolName);
+            return listed.find((tool) => tool.name === toolName);
         }
         catch {
             return undefined;
@@ -3499,10 +3559,11 @@ export class SessionEngine {
         // Single funnel for both append paths (appendEvent + the held-log emit),
         // so the storage sink sees every durable event exactly once.
         this.storage?.event(event);
+        this.livePublisher?.event(event);
         const chain = this.dispatchChains.get(sessionId) ?? Promise.resolve();
         const next = chain
             .then(() => this.dispatchEvent(sessionId, event, context))
-            .catch(error => {
+            .catch((error) => {
             this.logger(`[bdk] event dispatch failed for ${sessionId}: ${describeError(error)}`);
         })
             .then(() => {
@@ -3559,10 +3620,10 @@ export class SessionEngine {
             // context; merge turn-start → live so a last-event before/after cannot
             // drop earlier handler writes.
             if (context === undefined) {
-                await this.updateRecord(sessionId, current => ({ ...current }));
+                await this.updateRecord(sessionId, (current) => ({ ...current }));
             }
             else if (isTurnBoundaryEvent(event.type)) {
-                await this.updateRecord(sessionId, current => ({
+                await this.updateRecord(sessionId, (current) => ({
                     ...current,
                     channelState: mergeChannelStateMutation({
                         current: current.channelState,
@@ -3689,7 +3750,7 @@ export class SessionEngine {
         let matches;
         if (options?.includeAll !== true) {
             const owned = await this.ownedSessionIds(caller);
-            matches = record => record.sessionId !== undefined && owned.has(record.sessionId);
+            matches = (record) => record.sessionId !== undefined && owned.has(record.sessionId);
         }
         return this.artifactsStore.page({
             kind: options?.filter?.kind,
@@ -3723,7 +3784,9 @@ export class SessionEngine {
     }
     async ownedSessionIds(caller) {
         const sessions = await this.sessions.list();
-        return new Set(sessions.filter(record => samePrincipal(record.auth, caller)).map(record => record.sessionId));
+        return new Set(sessions
+            .filter((record) => samePrincipal(record.auth, caller))
+            .map((record) => record.sessionId));
     }
     /**
      * Same as {@link listSessions}, plus which store answered
@@ -3830,8 +3893,8 @@ export class SessionEngine {
     }
     summarizeSessionRecords(records, caller, includeAll) {
         return records
-            .filter(record => includeAll || samePrincipal(record.auth, caller))
-            .map(record => {
+            .filter((record) => includeAll || samePrincipal(record.auth, caller))
+            .map((record) => {
             const links = sessionExternalLinks(record);
             return {
                 sessionId: record.sessionId,
@@ -3876,7 +3939,7 @@ export class SessionEngine {
         if (existing === undefined) {
             throw new Error(`Unknown session: ${sessionId}`);
         }
-        const record = await this.updateRecord(sessionId, current => ({
+        const record = await this.updateRecord(sessionId, (current) => ({
             ...current,
             turnCount: current.turnCount + 1,
         }));
@@ -3928,7 +3991,7 @@ export class SessionEngine {
                 data: { ...completed.data, cost },
             });
         })
-            .catch(error => {
+            .catch((error) => {
             this.logger(`[bdk] turn cost stamp failed for ${sessionId}: ${describeError(error)}`);
         });
     }
@@ -4022,7 +4085,7 @@ export class SessionEngine {
             return pending;
         }
         const work = this.runCloudTurnCostBackfill(sessionId)
-            .catch(error => {
+            .catch((error) => {
             this.logger(`[bdk] cloud cost backfill failed for ${sessionId}: ${describeError(error)}`);
         })
             .finally(() => {
@@ -4034,8 +4097,9 @@ export class SessionEngine {
     async runCloudTurnCostBackfill(sessionId) {
         const log = await this.logs.get(sessionId);
         const events = await log.snapshot(0);
-        if (!events.some(event => isUnpricedCompletedTurn(event))) {
-            if (!this.isTurnRunning(sessionId) && events.some(event => event.type === "turn.completed")) {
+        if (!events.some((event) => isUnpricedCompletedTurn(event))) {
+            if (!this.isTurnRunning(sessionId) &&
+                events.some((event) => event.type === "turn.completed")) {
                 this.cloudCostBackfillDone.add(sessionId);
             }
             return;
@@ -4063,13 +4127,13 @@ export class SessionEngine {
             }
             log.replace(i, next);
         }
-        if (!(await log.snapshot(0)).some(event => isUnpricedCompletedTurn(event))) {
+        if (!(await log.snapshot(0)).some((event) => isUnpricedCompletedTurn(event))) {
             this.cloudCostBackfillDone.add(sessionId);
         }
     }
     async setContinuationToken(sessionId, token) {
         const previous = await this.sessions.get(sessionId);
-        await this.updateRecord(sessionId, current => ({
+        await this.updateRecord(sessionId, (current) => ({
             ...current,
             continuationKey: token,
         }));
@@ -4200,7 +4264,7 @@ export class SessionEngine {
         // the lazy continuation-lookup path.
         const cutoff = Date.now() - policy.maxAgeMs;
         const candidates = loaded
-            .map(record => ({
+            .map((record) => ({
             record,
             // Numeric timestamp for both the age filter and the sort; a
             // non-string updatedAt (e.g. a raw DB Date from an untyped sink)
@@ -4387,6 +4451,7 @@ export class SessionEngine {
         // After the drain, so a successor need not wait out the heartbeat TTL.
         await this.turnLeases.releaseAll().catch(() => { });
         await this.logs.flushAll();
+        this.livePublisher?.close();
         await this.storage?.close();
         await this.mcpHost.close();
         await this.runner.dispose?.();
@@ -4424,7 +4489,7 @@ function eventsNdjson(events) {
     if (events.length === 0) {
         return undefined;
     }
-    return `${events.map(event => JSON.stringify(event)).join("\n")}\n`;
+    return `${events.map((event) => JSON.stringify(event)).join("\n")}\n`;
 }
 /**
  * Restore-time turn-id fence: the durable record's `turnCount` may lag the
@@ -4460,7 +4525,7 @@ function subagentPrompt(subagent) {
  * executor that turn will run on.
  */
 function buildRunnerSubagents(agent) {
-    return agent.subagents.map(subagent => ({
+    return agent.subagents.map((subagent) => ({
         name: subagent.name,
         description: subagent.description ?? subagent.name,
         prompt: subagentPrompt(subagent),
@@ -4480,7 +4545,7 @@ async function defaultGetCloudUsage(sdkAgentId) {
         return {
             usage: mapSdkTokenUsage(billed.usage),
             cost: billed.cost,
-            runs: billed.runs.map(run => ({
+            runs: billed.runs.map((run) => ({
                 runId: run.runId,
                 usage: mapSdkTokenUsage(run.usage),
                 cost: run.cost,
@@ -4520,7 +4585,7 @@ function approvalResolverLabel(auth) {
 }
 /** Let the HTTP NDJSON writer flush before the next SDK update. */
 function yieldEventLoop() {
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         setImmediate(resolve);
     });
 }