@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/sdk-runner.js

@@ -5,15 +5,6 @@
  * settings; cloud agents use Cursor cloud (`bc-…` ids) with optional
  * `cloud` options from `defineAgent`.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { mkdir } from "node:fs/promises";
 import { Agent, Cursor, createAgentPlatform, } from "@cursor/sdk";
 import { SqliteLocalAgentStore } from "@cursor/sdk/sqlite";
@@ -35,9 +26,7 @@ export const SERVE_WORKSPACE_SCAN_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
  * not call `Cursor.configure`" and leave the SDK at its 20s editor default.
  */
 export function resolveServeWorkspaceScanCacheTtlMs(args) {
-    var _a;
-    var _b;
-    const raw = (_a = ((_b = args.env) !== null && _b !== void 0 ? _b : process.env).CURSOR_RIPWALK_CACHE_TTL_MS) === null || _a === void 0 ? void 0 : _a.trim();
+    const raw = (args.env ?? process.env).CURSOR_RIPWALK_CACHE_TTL_MS?.trim();
     if (raw !== undefined && raw !== "") {
         const parsed = Number(raw);
         if (Number.isFinite(parsed) && parsed > 0) {
@@ -155,12 +144,11 @@ function modelSettingLabel(model) {
 }
 /** Primary model, then authored fallbacks. No fallbacks keeps today's single attempt. */
 function modelAttemptChain(request) {
-    var _a, _b;
-    const fallbacks = (_a = request.modelFallbacks) !== null && _a !== void 0 ? _a : [];
+    const fallbacks = request.modelFallbacks ?? [];
     if (fallbacks.length === 0) {
         return [request.model];
     }
-    return [(_b = request.model) !== null && _b !== void 0 ? _b : DEFAULT_MODEL, ...fallbacks];
+    return [request.model ?? DEFAULT_MODEL, ...fallbacks];
 }
 /**
  * A rejected create may already have stored the agent id. Later attempts
@@ -170,17 +158,21 @@ function modelAttemptChain(request) {
  * on create: resuming the framework session id is not a cloud agent.
  */
 function modelAttemptRequest(request, model, attempt) {
-    var _a;
     if (attempt === 0) {
-        return model === request.model ? request : Object.assign(Object.assign({}, request), { model });
+        return model === request.model ? request : { ...request, model };
     }
-    const persistedId = (_a = request.sdkAgentId) !== null && _a !== void 0 ? _a : request.sessionId;
+    const persistedId = request.sdkAgentId ?? request.sessionId;
     if (request.runtime === "cloud" &&
         request.isFirstTurn &&
         !isServerMintedCloudAgentId(persistedId)) {
-        return Object.assign(Object.assign({}, request), { model });
-    }
-    return Object.assign(Object.assign({}, request), { model, isFirstTurn: false, sdkAgentId: persistedId });
+        return { ...request, model };
+    }
+    return {
+        ...request,
+        model,
+        isFirstTurn: false,
+        sdkAgentId: persistedId,
+    };
 }
 export class CursorSdkRunner {
     constructor(options = {}) {
@@ -197,49 +189,46 @@ export class CursorSdkRunner {
             this.log(`[bdk] workspace scan cache ttl=${options.workspaceScanCacheTtlMs}ms`);
         }
     }
-    runTurn(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            // Fail closed: this runner only knows the Cursor SDK's local and cloud
-            // harnesses. A grokbot turn reaching it means the serve wiring skipped
-            // the Grok Bot runner — running it on the local harness would silently
-            // swap the box (and the SendToUser contract) out from under the agent.
-            if (request.runtime === "grokbot") {
-                throw new Error(`Session ${request.sessionId} is a grokbot turn, which the local and cloud turn runner cannot execute. Serve must route grokbot turns to the Grok Bot runner.`);
-            }
-            const models = modelAttemptChain(request);
-            let lastError;
-            for (let attempt = 0; attempt < models.length; attempt++) {
-                const model = models[attempt];
-                let streamed = false;
-                const attemptRequest = modelAttemptRequest(request, model, attempt);
-                try {
-                    const outcome = yield this.runTurnWithTransportRetry(attemptRequest, () => {
-                        streamed = true;
-                    });
-                    if (outcome.status !== "error" ||
-                        streamed ||
-                        ((_a = request.signal) === null || _a === void 0 ? void 0 : _a.aborted) === true ||
-                        !shouldFallbackToNextModel(outcome.errorMessage, outcome.errorCode) ||
-                        attempt === models.length - 1) {
-                        return outcome;
-                    }
-                    this.logModelFallback(request.sessionId, model, models[attempt + 1], outcome.errorMessage);
+    async runTurn(request) {
+        // Fail closed: this runner only knows the Cursor SDK's local and cloud
+        // harnesses. A grokbot turn reaching it means the serve wiring skipped
+        // the Grok Bot runner — running it on the local harness would silently
+        // swap the box (and the SendToUser contract) out from under the agent.
+        if (request.runtime === "grokbot") {
+            throw new Error(`Session ${request.sessionId} is a grokbot turn, which the local and cloud turn runner cannot execute. Serve must route grokbot turns to the Grok Bot runner.`);
+        }
+        const models = modelAttemptChain(request);
+        let lastError;
+        for (let attempt = 0; attempt < models.length; attempt++) {
+            const model = models[attempt];
+            let streamed = false;
+            const attemptRequest = modelAttemptRequest(request, model, attempt);
+            try {
+                const outcome = await this.runTurnWithTransportRetry(attemptRequest, () => {
+                    streamed = true;
+                });
+                if (outcome.status !== "error" ||
+                    streamed ||
+                    request.signal?.aborted === true ||
+                    !shouldFallbackToNextModel(outcome.errorMessage, outcome.errorCode) ||
+                    attempt === models.length - 1) {
+                    return outcome;
                 }
-                catch (error) {
-                    lastError = error;
-                    if (streamed ||
-                        ((_b = request.signal) === null || _b === void 0 ? void 0 : _b.aborted) === true ||
-                        !shouldFallbackToNextModelOnError(error) ||
-                        attempt === models.length - 1) {
-                        throw error;
-                    }
-                    const message = error instanceof Error ? error.message : undefined;
-                    this.logModelFallback(request.sessionId, model, models[attempt + 1], message);
+                this.logModelFallback(request.sessionId, model, models[attempt + 1], outcome.errorMessage);
+            }
+            catch (error) {
+                lastError = error;
+                if (streamed ||
+                    request.signal?.aborted === true ||
+                    !shouldFallbackToNextModelOnError(error) ||
+                    attempt === models.length - 1) {
+                    throw error;
                 }
+                const message = error instanceof Error ? error.message : undefined;
+                this.logModelFallback(request.sessionId, model, models[attempt + 1], message);
             }
-            throw lastError;
-        });
+        }
+        throw lastError;
     }
     /**
      * One model attempt, plus the existing in-place transport retry (expired
@@ -247,172 +236,179 @@ export class CursorSdkRunner {
      * fallback is the caller's job: this returns the error outcome when a
      * fresh handle cannot fix it.
      */
-    runTurnWithTransportRetry(request, onStreamed) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            let sawUpdate = false;
-            const tracked = Object.assign(Object.assign({}, request), { onUpdate: update => {
-                    sawUpdate = true;
-                    onStreamed();
-                    return request.onUpdate(update);
-                } });
-            const outcome = yield this.runTurnAttempt(tracked);
-            if (outcome.status !== "error" || sawUpdate || ((_a = request.signal) === null || _a === void 0 ? void 0 : _a.aborted) === true) {
-                return outcome;
-            }
-            const reason = retryReason(outcome.errorMessage, request.isFirstTurn);
-            if (reason === undefined) {
-                return outcome;
-            }
-            // Log the original error even when the retry succeeds so the expiry
-            // still shows up in Datadog.
-            this.log(`[bdk] session ${request.sessionId}: ${reason}: ${outcome.errorMessage}; retrying the turn`);
-            try {
-                return yield this.runTurnAttempt(tracked);
-            }
-            catch (_b) {
-                return outcome;
-            }
-        });
+    async runTurnWithTransportRetry(request, onStreamed) {
+        let sawUpdate = false;
+        const tracked = {
+            ...request,
+            onUpdate: update => {
+                sawUpdate = true;
+                onStreamed();
+                return request.onUpdate(update);
+            },
+        };
+        const outcome = await this.runTurnAttempt(tracked);
+        if (outcome.status !== "error" || sawUpdate || request.signal?.aborted === true) {
+            return outcome;
+        }
+        const reason = retryReason(outcome.errorMessage, request.isFirstTurn);
+        if (reason === undefined) {
+            return outcome;
+        }
+        // Log the original error even when the retry succeeds so the expiry
+        // still shows up in Datadog.
+        this.log(`[bdk] session ${request.sessionId}: ${reason}: ${outcome.errorMessage}; retrying the turn`);
+        try {
+            return await this.runTurnAttempt(tracked);
+        }
+        catch {
+            return outcome;
+        }
     }
     logModelFallback(sessionId, from, to, message) {
-        this.log(`[bdk] session ${sessionId}: cannot use model ${modelSettingLabel(from)}; retrying on ${modelSettingLabel(to)}: ${message !== null && message !== void 0 ? message : "model unavailable"}`);
-    }
-    runTurnAttempt(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const agentPromise = this.getAgent(request);
-            try {
-                const agent = yield agentPromise;
-                const sendMessage = request.images !== undefined && request.images.length > 0
-                    ? {
-                        text: request.prompt,
-                        images: request.images.map(image => ({
-                            data: image.data,
-                            mimeType: image.mimeType,
-                        })),
+        this.log(`[bdk] session ${sessionId}: cannot use model ${modelSettingLabel(from)}; retrying on ${modelSettingLabel(to)}: ${message ?? "model unavailable"}`);
+    }
+    async runTurnAttempt(request) {
+        const agentPromise = this.getAgent(request);
+        try {
+            const agent = await agentPromise;
+            const sendMessage = request.images !== undefined && request.images.length > 0
+                ? {
+                    text: request.prompt,
+                    images: request.images.map(image => ({
+                        data: image.data,
+                        mimeType: image.mimeType,
+                    })),
+                }
+                : request.prompt;
+            const run = await agent.send(sendMessage, {
+                onDelta: async ({ update }) => {
+                    try {
+                        await request.onUpdate(update);
+                    }
+                    catch {
+                        // Stream mapping must never reject into the SDK transport.
                     }
-                    : request.prompt;
-                const run = yield agent.send(sendMessage, Object.assign(Object.assign({ onDelta: (_a) => __awaiter(this, [_a], void 0, function* ({ update }) {
-                        try {
-                            yield request.onUpdate(update);
-                        }
-                        catch (_b) {
-                            // Stream mapping must never reject into the SDK transport.
-                        }
-                    }) }, (request.runtime === "local" && request.perSendMcpServers === true
+                },
+                // The SDK builds this send's MCP session from exactly this set, so
+                // a turn always runs on the headers the engine evaluated for it —
+                // never on the ones a previous turn opened the cached handle with.
+                ...(request.runtime === "local" && request.perSendMcpServers === true
                     ? { mcpServers: request.mcpServers }
-                    : {})), (request.runtime === "local"
+                    : {}),
+                ...(request.runtime === "local"
                     ? {
-                        local: Object.assign({ customTools: request.customTools }, (request.forceExpireActiveRun === true ? { force: true } : {})),
-                    }
-                    : {})));
-                // A follow-up can preempt this turn: cancelling tears down execution and
-                // marks the SDK run terminal so the next send is admitted cleanly. The
-                // signal may already be aborted if the preempt landed while send() was
-                // still creating the run.
-                const signal = request.signal;
-                const onAbort = () => {
-                    void run.cancel().catch(() => { });
-                };
-                if (signal !== undefined) {
-                    if (signal.aborted) {
-                        onAbort();
-                    }
-                    else {
-                        signal.addEventListener("abort", onAbort, { once: true });
-                    }
-                }
-                // Cloud + envVars: server mints the real `bc-…` id during createAgent
-                // inside the first send. Bind only after that so we never persist/print
-                // the provisional client-seeded id.
-                if (request.onSdkAgentId !== undefined) {
-                    yield request.onSdkAgentId(agent.agentId);
-                }
-                // Readable on the handle as soon as send resolves, long before wait().
-                if (request.onRequestId !== undefined &&
-                    run.requestId !== undefined &&
-                    run.requestId !== "") {
-                    yield request.onRequestId(run.requestId);
-                }
-                this.activeRuns.set(request.sessionId, run);
-                try {
-                    const result = yield run.wait();
-                    let outcome = toTurnOutcome(result);
-                    if (outcome.status === "error") {
-                        // An error result usually means the handle's transport is poisoned
-                        // — most often a cached access token that aged past its 60-minute
-                        // lifetime and gets replayed on every request (stream failures
-                        // bypass the transport's 401 retry). Retire the handle so the next
-                        // attempt resumes the conversation from the store on a fresh
-                        // transport instead of failing every turn until a restart.
-                        this.evictAgent(request.sessionId, agentPromise);
-                    }
-                    else if (request.runtime === "cloud" &&
-                        outcome.status === "finished" &&
-                        usageTokenSum(outcome.usage) <= 0 &&
-                        result.id !== "") {
-                        // Cloud `wait()` drops usage after stream reconnect / getRun replay,
-                        // or returns an all-zero stub. `getUsage` still has the run's tokens
-                        // (eventually); without them traces never record an estimated cost.
-                        outcome = yield fillMissingCloudUsage(agent, result.id, outcome);
+                        local: {
+                            customTools: request.customTools,
+                            // Follow-up turns expire any run still marked active on the
+                            // agent (a preempted or crash-wedged run) so this send is not
+                            // rejected with "already has active run".
+                            ...(request.forceExpireActiveRun === true ? { force: true } : {}),
+                        },
                     }
-                    return outcome;
+                    : {}),
+            });
+            // A follow-up can preempt this turn: cancelling tears down execution and
+            // marks the SDK run terminal so the next send is admitted cleanly. The
+            // signal may already be aborted if the preempt landed while send() was
+            // still creating the run.
+            const signal = request.signal;
+            const onAbort = () => {
+                void run.cancel().catch(() => { });
+            };
+            if (signal !== undefined) {
+                if (signal.aborted) {
+                    onAbort();
                 }
-                finally {
-                    if (this.activeRuns.get(request.sessionId) === run) {
-                        this.activeRuns.delete(request.sessionId);
-                    }
-                    signal === null || signal === void 0 ? void 0 : signal.removeEventListener("abort", onAbort);
-                    // Mirror the conversation without holding the turn outcome: on
-                    // hosted v2 the pod can be parked as soon as the execution reply
-                    // lands, so the engine's durability drain awaits this write through
-                    // drainConversation before that reply, not before turn.completed.
-                    // In the `finally` so a `wait()` that THROWS (transport death
-                    // mid-turn, an abort with no follow-up) still persists the
-                    // checkpoints the turn already wrote — the store is local SQLite,
-                    // safe to read on the throw path, and persistConversation swallows
-                    // its own errors. Guarded here (not just inside the helper) so
-                    // unmirrored turns keep their exact post-wait sequencing.
-                    if (request.runtime === "local" && this.options.conversationMirror !== undefined) {
-                        this.trackPersist(request.sessionId, this.persistConversation(request, agent.agentId));
-                    }
+                else {
+                    signal.addEventListener("abort", onAbort, { once: true });
                 }
             }
-            catch (error) {
-                // Drop the cached agent so a dead Connect/HTTP2 session cannot poison
-                // the next turn (terminal/shell overflow often kills the transport).
-                this.evictAgent(request.sessionId, agentPromise);
-                throw error;
+            // Cloud + envVars: server mints the real `bc-…` id during createAgent
+            // inside the first send. Bind only after that so we never persist/print
+            // the provisional client-seeded id.
+            if (request.onSdkAgentId !== undefined) {
+                await request.onSdkAgentId(agent.agentId);
             }
-        });
-    }
-    steer(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const run = this.activeRuns.get(request.sessionId);
-            if ((run === null || run === void 0 ? void 0 : run.steer) === undefined) {
-                return "revert_to_followup";
+            // Readable on the handle as soon as send resolves, long before wait().
+            if (request.onRequestId !== undefined &&
+                run.requestId !== undefined &&
+                run.requestId !== "") {
+                await request.onRequestId(run.requestId);
             }
+            this.activeRuns.set(request.sessionId, run);
             try {
-                return yield run.steer(request.text);
+                const result = await run.wait();
+                let outcome = toTurnOutcome(result);
+                if (outcome.status === "error") {
+                    // An error result usually means the handle's transport is poisoned
+                    // — most often a cached access token that aged past its 60-minute
+                    // lifetime and gets replayed on every request (stream failures
+                    // bypass the transport's 401 retry). Retire the handle so the next
+                    // attempt resumes the conversation from the store on a fresh
+                    // transport instead of failing every turn until a restart.
+                    this.evictAgent(request.sessionId, agentPromise);
+                }
+                else if (request.runtime === "cloud" &&
+                    outcome.status === "finished" &&
+                    usageTokenSum(outcome.usage) <= 0 &&
+                    result.id !== "") {
+                    // Cloud `wait()` drops usage after stream reconnect / getRun replay,
+                    // or returns an all-zero stub. `getUsage` still has the run's tokens
+                    // (eventually); without them traces never record an estimated cost.
+                    outcome = await fillMissingCloudUsage(agent, result.id, outcome);
+                }
+                return outcome;
             }
-            catch (error) {
-                this.log(`[bdk] session ${request.sessionId}: steer failed: ${describeError(error)}`);
-                return "revert_to_followup";
+            finally {
+                if (this.activeRuns.get(request.sessionId) === run) {
+                    this.activeRuns.delete(request.sessionId);
+                }
+                signal?.removeEventListener("abort", onAbort);
+                // Mirror the conversation without holding the turn outcome: on
+                // hosted v2 the pod can be parked as soon as the execution reply
+                // lands, so the engine's durability drain awaits this write through
+                // drainConversation before that reply, not before turn.completed.
+                // In the `finally` so a `wait()` that THROWS (transport death
+                // mid-turn, an abort with no follow-up) still persists the
+                // checkpoints the turn already wrote — the store is local SQLite,
+                // safe to read on the throw path, and persistConversation swallows
+                // its own errors. Guarded here (not just inside the helper) so
+                // unmirrored turns keep their exact post-wait sequencing.
+                if (request.runtime === "local" && this.options.conversationMirror !== undefined) {
+                    this.trackPersist(request.sessionId, this.persistConversation(request, agent.agentId));
+                }
             }
-        });
+        }
+        catch (error) {
+            // Drop the cached agent so a dead Connect/HTTP2 session cannot poison
+            // the next turn (terminal/shell overflow often kills the transport).
+            this.evictAgent(request.sessionId, agentPromise);
+            throw error;
+        }
+    }
+    async steer(request) {
+        const run = this.activeRuns.get(request.sessionId);
+        if (run?.steer === undefined) {
+            return "revert_to_followup";
+        }
+        try {
+            return await run.steer(request.text);
+        }
+        catch (error) {
+            this.log(`[bdk] session ${request.sessionId}: steer failed: ${describeError(error)}`);
+            return "revert_to_followup";
+        }
     }
     /**
      * Build the local executor for a workspace before any session asks for it.
      * The warmed executor is reference counted, so the lease is held until
      * {@link dispose}; dropping it early would tear the workspace back down.
      */
-    prewarm(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const platform = yield createAgentPlatform();
-            const release = yield platform.prewarmLocalWorkspace(yield this.buildLocalOptions(request));
-            this.prewarmReleases.push(release);
-            return { warmed: true };
-        });
+    async prewarm(request) {
+        const platform = await createAgentPlatform();
+        const release = await platform.prewarmLocalWorkspace(await this.buildLocalOptions(request));
+        this.prewarmReleases.push(release);
+        return { warmed: true };
     }
     /**
      * Drop the cached SDK agent for this session, if one is open.
@@ -432,10 +428,8 @@ export class CursorSdkRunner {
         }
         this.evictAgent(sessionId, cached.agent);
     }
-    drainConversation(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.pendingPersists.get(sessionId);
-        });
+    async drainConversation(sessionId) {
+        await this.pendingPersists.get(sessionId);
     }
     trackPersist(sessionId, persist) {
         const tracked = Promise.all([this.pendingPersists.get(sessionId), persist]).then(() => {
@@ -445,19 +439,17 @@ export class CursorSdkRunner {
         });
         this.pendingPersists.set(sessionId, tracked);
     }
-    dispose() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.allSettled([...this.pendingPersists.values()]);
-            const releases = this.prewarmReleases.splice(0);
-            yield Promise.allSettled(releases.map(release => release()));
-            const agents = yield Promise.allSettled([...this.agents.values()].map(handle => handle.agent));
-            this.agents.clear();
-            for (const settled of agents) {
-                if (settled.status === "fulfilled") {
-                    settled.value.close();
-                }
+    async dispose() {
+        await Promise.allSettled([...this.pendingPersists.values()]);
+        const releases = this.prewarmReleases.splice(0);
+        await Promise.allSettled(releases.map(release => release()));
+        const agents = await Promise.allSettled([...this.agents.values()].map(handle => handle.agent));
+        this.agents.clear();
+        for (const settled of agents) {
+            if (settled.status === "fulfilled") {
+                settled.value.close();
             }
-        });
+        }
     }
     getAgent(request) {
         const cached = this.agents.get(request.sessionId);
@@ -468,7 +460,7 @@ export class CursorSdkRunner {
             }
             // Past this age the handle's exchanged access token could expire
             // mid-turn. Retire it and reopen below on a fresh transport.
-            this.log(`[bdk] session ${request.sessionId}: recycling the SDK agent handle after ${Math.round(ageMs / 60000)} min so the turn runs on a fresh access token`);
+            this.log(`[bdk] session ${request.sessionId}: recycling the SDK agent handle after ${Math.round(ageMs / 60_000)} min so the turn runs on a fresh access token`);
             this.evictAgent(request.sessionId, cached.agent);
         }
         const agentPromise = this.openAgent(request).catch(error => {
@@ -496,8 +488,7 @@ export class CursorSdkRunner {
         void cached.agent.then(sdkAgent => sdkAgent.close()).catch(() => { });
     }
     log(line) {
-        var _a;
-        ((_a = this.options.logger) !== null && _a !== void 0 ? _a : (() => { }))(line);
+        (this.options.logger ?? (() => { }))(line);
     }
     /**
      * Re-resolve on every turn. Hosted freeze snapshots listen unsigned; the
@@ -512,111 +503,128 @@ export class CursorSdkRunner {
         return resolved.apiKey;
     }
     buildSharedOptions(request) {
-        var _a;
         const subagents = toAgentDefinitions(request.subagents);
-        return Object.assign(Object.assign({ model: toModelSelection((_a = request.model) !== null && _a !== void 0 ? _a : DEFAULT_MODEL), apiKey: this.requireApiKey() }, (Object.keys(request.mcpServers).length > 0 && request.perSendMcpServers !== true
-            ? { mcpServers: request.mcpServers }
-            : {})), (subagents === undefined ? {} : { agents: subagents }));
+        return {
+            model: toModelSelection(request.model ?? DEFAULT_MODEL),
+            apiKey: this.requireApiKey(),
+            // Per-send servers ride each agent.send instead (fresh per-session
+            // auth headers every turn). Keeping them out of the create/resume
+            // options also keeps the local executor cache key — which hashes
+            // these options — stable while credentials rotate.
+            ...(Object.keys(request.mcpServers).length > 0 && request.perSendMcpServers !== true
+                ? { mcpServers: request.mcpServers }
+                : {}),
+            ...(subagents === undefined ? {} : { agents: subagents }),
+        };
     }
     /**
      * The options that decide which local executor a turn runs on. Prewarming
      * goes through here too, so a warmed workspace is the one turns land on.
      */
-    buildLocalOptions(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            // Not resolveStore: an injected store is used synchronously (no
-            // microtask, no thenable assimilation), exactly as before the mirror
-            // existed.
-            const store = (_a = this.options.store) !== null && _a !== void 0 ? _a : (yield this.getStore(request.runnerStateDir));
-            return Object.assign(Object.assign(Object.assign(Object.assign({}, this.buildSharedOptions(request)), (request.tools === undefined ? {} : { tools: request.tools })), (request.disallowedTools === undefined
+    async buildLocalOptions(request) {
+        // Not resolveStore: an injected store is used synchronously (no
+        // microtask, no thenable assimilation), exactly as before the mirror
+        // existed.
+        const store = this.options.store ?? (await this.getStore(request.runnerStateDir));
+        return {
+            ...this.buildSharedOptions(request),
+            // The built-in tool allowlist rides AgentOptions, not `local`, and is
+            // deliberately absent from openCloudAgent's options: the SDK rejects
+            // tool restrictions on cloud agents. Passed on create *and* resume
+            // (both flow through here) — the SDK does not persist it across runs.
+            ...(request.tools === undefined ? {} : { tools: request.tools }),
+            ...(request.disallowedTools === undefined
                 ? {}
-                : { disallowedTools: request.disallowedTools })), { 
-                // Same shape: local-only (the SDK rejects it with `cloud`), not
-                // persisted, so it rides every create/resume. Replaces Cursor's
-                // built-in system prompt with the agent's composed instructions.
-                // Prewarm requests carry none, and the SDK's workspace cache key
-                // ignores it, so a warmed executor is still the one turns land on.
-                systemPrompt: request.instructions, local: Object.assign({ cwd: request.workspaceDir, settingSources: ["project"], store }, (request.sandbox === true ? { sandboxOptions: { enabled: true } } : {})) });
-        });
-    }
-    openAgent(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (request.runtime === "cloud") {
-                return this.openCloudAgent(request, this.buildSharedOptions(request));
-            }
-            return this.openLocalAgent(request);
-        });
+                : { disallowedTools: request.disallowedTools }),
+            // Same shape: local-only (the SDK rejects it with `cloud`), not
+            // persisted, so it rides every create/resume. Replaces Cursor's
+            // built-in system prompt with the agent's composed instructions.
+            // Prewarm requests carry none, and the SDK's workspace cache key
+            // ignores it, so a warmed executor is still the one turns land on.
+            systemPrompt: request.instructions,
+            local: {
+                cwd: request.workspaceDir,
+                settingSources: ["project"],
+                store,
+                ...(request.sandbox === true ? { sandboxOptions: { enabled: true } } : {}),
+            },
+        };
     }
-    openLocalAgent(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const options = yield this.buildLocalOptions(request);
-            if (request.isFirstTurn || request.sdkAgentId === undefined) {
-                return Agent.create(Object.assign(Object.assign({}, options), { agentId: (_a = request.sdkAgentId) !== null && _a !== void 0 ? _a : request.sessionId }));
-            }
-            const agentId = (_b = request.sdkAgentId) !== null && _b !== void 0 ? _b : request.sessionId;
-            const mirror = this.options.conversationMirror;
-            if (mirror !== undefined) {
-                // Host replacement: restore the conversation from the durable mirror
-                // before resuming, so the thread continues instead of starting fresh.
-                // A sink failure propagates and fails the turn (retryable) — reading
-                // an outage as "nothing mirrored" would silently fork the thread.
-                const store = yield this.resolveStore(request);
-                yield mirror.hydrate(store, agentId);
-            }
-            try {
-                return yield Agent.resume(agentId, options);
-            }
-            catch (error) {
-                if (!isLocalAgentNotFoundError(error, agentId)) {
-                    throw error;
-                }
-                // Host replacement: the session record survived in durable storage,
-                // but the conversation store died with the old pod. A fresh
-                // conversation under the same id beats failing this thread's turns
-                // forever ("Agent … not found" on every follow-up). The channel's
-                // warm-turn prompt context re-hydrates the thread history.
-                this.log(`[bdk] no stored conversation for ${agentId} on this host; starting a fresh one`);
-                return Agent.create(Object.assign(Object.assign({}, options), { agentId }));
+    async openAgent(request) {
+        if (request.runtime === "cloud") {
+            return this.openCloudAgent(request, this.buildSharedOptions(request));
+        }
+        return this.openLocalAgent(request);
+    }
+    async openLocalAgent(request) {
+        const options = await this.buildLocalOptions(request);
+        if (request.isFirstTurn || request.sdkAgentId === undefined) {
+            return Agent.create({
+                ...options,
+                agentId: request.sdkAgentId ?? request.sessionId,
+            });
+        }
+        const agentId = request.sdkAgentId ?? request.sessionId;
+        const mirror = this.options.conversationMirror;
+        if (mirror !== undefined) {
+            // Host replacement: restore the conversation from the durable mirror
+            // before resuming, so the thread continues instead of starting fresh.
+            // A sink failure propagates and fails the turn (retryable) — reading
+            // an outage as "nothing mirrored" would silently fork the thread.
+            const store = await this.resolveStore(request);
+            await mirror.hydrate(store, agentId);
+        }
+        try {
+            return await Agent.resume(agentId, options);
+        }
+        catch (error) {
+            if (!isLocalAgentNotFoundError(error, agentId)) {
+                throw error;
             }
-        });
+            // Host replacement: the session record survived in durable storage,
+            // but the conversation store died with the old pod. A fresh
+            // conversation under the same id beats failing this thread's turns
+            // forever ("Agent … not found" on every follow-up). The channel's
+            // warm-turn prompt context re-hydrates the thread history.
+            this.log(`[bdk] no stored conversation for ${agentId} on this host; starting a fresh one`);
+            return Agent.create({ ...options, agentId });
+        }
     }
-    openCloudAgent(request, shared) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const cloud = toCloudAgentOptions(request.cloud, request.agentServeAgent);
-            const hasEnvVars = cloud.envVars !== undefined && Object.keys(cloud.envVars).length > 0;
-            const options = Object.assign(Object.assign({}, shared), { cloud });
-            const sdkAgentId = (_a = request.sdkAgentId) === null || _a === void 0 ? void 0 : _a.trim();
-            if (sdkAgentId !== undefined && sdkAgentId !== "") {
-                // A server-minted `bc-…` id always resumes — including on the first
-                // framework turn of a session seeded via SendMessageOptions.sdkAgentId
-                // (PR→bcId affinity across session-store resets). Any persisted id
-                // resumes on later turns.
-                if (isServerMintedCloudAgentId(sdkAgentId) || !request.isFirstTurn) {
-                    return Agent.resume(sdkAgentId, options);
-                }
-                if (!hasEnvVars) {
-                    // Client-seeded (non bc-…) id on a brand new session: forward it to
-                    // create so the server adopts it. With envVars the server must mint
-                    // the id, so the seed cannot be honored and create() runs below.
-                    return Agent.create(Object.assign(Object.assign({}, options), { agentId: sdkAgentId }));
-                }
+    async openCloudAgent(request, shared) {
+        const cloud = toCloudAgentOptions(request.cloud, request.agentServeAgent);
+        const hasEnvVars = cloud.envVars !== undefined && Object.keys(cloud.envVars).length > 0;
+        const options = {
+            ...shared,
+            cloud,
+        };
+        const sdkAgentId = request.sdkAgentId?.trim();
+        if (sdkAgentId !== undefined && sdkAgentId !== "") {
+            // A server-minted `bc-…` id always resumes — including on the first
+            // framework turn of a session seeded via SendMessageOptions.sdkAgentId
+            // (PR→bcId affinity across session-store resets). Any persisted id
+            // resumes on later turns.
+            if (isServerMintedCloudAgentId(sdkAgentId) || !request.isFirstTurn) {
+                return Agent.resume(sdkAgentId, options);
             }
-            if (request.isFirstTurn) {
-                return Agent.create(options);
+            if (!hasEnvVars) {
+                // Client-seeded (non bc-…) id on a brand new session: forward it to
+                // create so the server adopts it. With envVars the server must mint
+                // the id, so the seed cannot be honored and create() runs below.
+                return Agent.create({ ...options, agentId: sdkAgentId });
             }
-            // A cloud session past its first turn should carry the bound agent id
-            // (the engine persists it via onSdkAgentId as soon as create() reports
-            // one). Reaching here means the binding turn failed before the server
-            // ever minted an agent — e.g. create() rejected its PR attach — so the
-            // session would otherwise fail every future turn. Mirror the local
-            // host-replacement path above: a fresh conversation beats failing this
-            // thread forever, and the new id binds to the session for later resumes.
-            this.log(`[bdk] cloud session ${request.sessionId} has no bound cloud agent; creating a fresh one`);
+        }
+        if (request.isFirstTurn) {
             return Agent.create(options);
-        });
+        }
+        // A cloud session past its first turn should carry the bound agent id
+        // (the engine persists it via onSdkAgentId as soon as create() reports
+        // one). Reaching here means the binding turn failed before the server
+        // ever minted an agent — e.g. create() rejected its PR attach — so the
+        // session would otherwise fail every future turn. Mirror the local
+        // host-replacement path above: a fresh conversation beats failing this
+        // thread forever, and the new id binds to the session for later resumes.
+        this.log(`[bdk] cloud session ${request.sessionId} has no bound cloud agent; creating a fresh one`);
+        return Agent.create(options);
     }
     resolveStore(request) {
         return this.options.store !== undefined
@@ -627,20 +635,18 @@ export class CursorSdkRunner {
      * Mirror the settled turn's conversation. Persist failures are logged and
      * dropped — a durable-mirror outage must not fail a turn that already ran.
      */
-    persistConversation(request, sdkAgentId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mirror = this.options.conversationMirror;
-            if (mirror === undefined) {
-                return;
-            }
-            try {
-                const store = yield this.resolveStore(request);
-                yield mirror.persist(store, sdkAgentId);
-            }
-            catch (error) {
-                this.log(`[bdk] conversation mirror: persist for ${sdkAgentId} failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        });
+    async persistConversation(request, sdkAgentId) {
+        const mirror = this.options.conversationMirror;
+        if (mirror === undefined) {
+            return;
+        }
+        try {
+            const store = await this.resolveStore(request);
+            await mirror.persist(store, sdkAgentId);
+        }
+        catch (error) {
+            this.log(`[bdk] conversation mirror: persist for ${sdkAgentId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     getStore(stateDir) {
         let storePromise = this.stores.get(stateDir);
@@ -673,14 +679,25 @@ export function toModelSelection(model) {
     if (typeof model === "string") {
         return { id: model };
     }
-    return Object.assign({ id: model.id }, (model.params === undefined ? {} : { params: model.params }));
+    return {
+        id: model.id,
+        ...(model.params === undefined ? {} : { params: model.params }),
+    };
 }
 function toCloudAgentOptions(cloud, agentServeAgent) {
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, ((cloud === null || cloud === void 0 ? void 0 : cloud.env) === undefined ? {} : { env: cloud.env })), ((cloud === null || cloud === void 0 ? void 0 : cloud.repos) === undefined ? {} : { repos: cloud.repos })), ((cloud === null || cloud === void 0 ? void 0 : cloud.workOnCurrentBranch) === undefined
-        ? {}
-        : { workOnCurrentBranch: cloud.workOnCurrentBranch })), ((cloud === null || cloud === void 0 ? void 0 : cloud.autoCreatePR) === undefined ? {} : { autoCreatePR: cloud.autoCreatePR })), ((cloud === null || cloud === void 0 ? void 0 : cloud.skipReviewerRequest) === undefined
-        ? {}
-        : { skipReviewerRequest: cloud.skipReviewerRequest })), ((cloud === null || cloud === void 0 ? void 0 : cloud.envVars) === undefined ? {} : { envVars: cloud.envVars })), (agentServeAgent === undefined ? {} : { agentServeAgent }));
+    return {
+        ...(cloud?.env === undefined ? {} : { env: cloud.env }),
+        ...(cloud?.repos === undefined ? {} : { repos: cloud.repos }),
+        ...(cloud?.workOnCurrentBranch === undefined
+            ? {}
+            : { workOnCurrentBranch: cloud.workOnCurrentBranch }),
+        ...(cloud?.autoCreatePR === undefined ? {} : { autoCreatePR: cloud.autoCreatePR }),
+        ...(cloud?.skipReviewerRequest === undefined
+            ? {}
+            : { skipReviewerRequest: cloud.skipReviewerRequest }),
+        ...(cloud?.envVars === undefined ? {} : { envVars: cloud.envVars }),
+        ...(agentServeAgent === undefined ? {} : { agentServeAgent }),
+    };
 }
 function toAgentDefinitions(subagents) {
     if (subagents.length === 0) {
@@ -697,13 +714,24 @@ function toAgentDefinitions(subagents) {
     return definitions;
 }
 function toTurnOutcome(result) {
-    var _a;
     const usage = result.usage === undefined
         ? undefined
-        : Object.assign({ inputTokens: result.usage.inputTokens, outputTokens: result.usage.outputTokens, cacheReadTokens: result.usage.cacheReadTokens, cacheWriteTokens: result.usage.cacheWriteTokens }, (result.usage.reasoningTokens === undefined
-            ? {}
-            : { reasoningTokens: result.usage.reasoningTokens }));
-    return Object.assign(Object.assign(Object.assign(Object.assign({ status: result.status }, (result.result === undefined ? {} : { result: result.result })), (result.status === "error" ? { errorMessage: runErrorMessage(result) } : {})), { errorCode: result.status === "error" ? (_a = result.error) === null || _a === void 0 ? void 0 : _a.code : undefined }), (usage === undefined ? {} : { usage }));
+        : {
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
+            cacheReadTokens: result.usage.cacheReadTokens,
+            cacheWriteTokens: result.usage.cacheWriteTokens,
+            ...(result.usage.reasoningTokens === undefined
+                ? {}
+                : { reasoningTokens: result.usage.reasoningTokens }),
+        };
+    return {
+        status: result.status,
+        ...(result.result === undefined ? {} : { result: result.result }),
+        ...(result.status === "error" ? { errorMessage: runErrorMessage(result) } : {}),
+        errorCode: result.status === "error" ? result.error?.code : undefined,
+        ...(usage === undefined ? {} : { usage }),
+    };
 }
 /** Billing can lag briefly after `wait()`; retry before giving up on cost. */
 const CLOUD_USAGE_RETRY_DELAYS_MS = [0, 400, 1200];
@@ -712,28 +740,25 @@ const CLOUD_USAGE_RETRY_DELAYS_MS = [0, 400, 1200];
  * tokens from the usage API so the engine can still price the turn.
  * Failures are ignored: a missing estimate is better than failing the turn.
  */
-function fillMissingCloudUsage(agent, runId, outcome) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const delayMs of CLOUD_USAGE_RETRY_DELAYS_MS) {
-            if (delayMs > 0) {
-                yield sleep(delayMs);
-            }
-            try {
-                const billed = yield agent.getUsage({ runId });
-                const mapped = mapSdkTokenUsage(billed.usage);
-                if (usageTokenSum(mapped) <= 0) {
-                    continue;
-                }
-                return Object.assign(Object.assign({}, outcome), { usage: mapped });
-            }
-            catch (_a) {
-                // Transient usage-API failures should still burn the retry budget.
+async function fillMissingCloudUsage(agent, runId, outcome) {
+    for (const delayMs of CLOUD_USAGE_RETRY_DELAYS_MS) {
+        if (delayMs > 0) {
+            await sleep(delayMs);
+        }
+        try {
+            const billed = await agent.getUsage({ runId });
+            const mapped = mapSdkTokenUsage(billed.usage);
+            if (usageTokenSum(mapped) <= 0) {
+                continue;
             }
+            return { ...outcome, usage: mapped };
+        }
+        catch {
+            // Transient usage-API failures should still burn the retry budget.
         }
-        return outcome;
-    });
+    }
+    return outcome;
 }
 export function runErrorMessage(result) {
-    var _a, _b;
-    return ((_b = (_a = result.error) === null || _a === void 0 ? void 0 : _a.message) === null || _b === void 0 ? void 0 : _b.trim()) || "The Cursor agent run failed";
+    return result.error?.message?.trim() || "The Cursor agent run failed";
 }