@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/hosted-delivery.js

@@ -1,12 +1,3 @@
-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 { randomBytes } from "node:crypto";
 import { packageVersion } from "./distribution.js";
 import { dispatchOutcome } from "./channel-dispatch.js";
@@ -27,19 +18,16 @@ import { endActiveHttpSpan } from "./otel/http.js";
 import { ReminderValidationError, UnknownReminderError } from "./reminder-runner.js";
 import { mapThrownRequestError, statusForThrownRequestError } from "./request-error-status.js";
 import { HostedEnqueueNotActiveError } from "./session-engine.js";
-function responseToReply(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const value = (yield response.json());
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-            throw new Error("Hosted delivery produced a non-object JSON response.");
-        }
-        return {
-            status: response.status,
-            body: value,
-            serverTiming: (_a = response.headers.get("server-timing")) !== null && _a !== void 0 ? _a : undefined,
-        };
-    });
+async function responseToReply(response) {
+    const value = (await response.json());
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("Hosted delivery produced a non-object JSON response.");
+    }
+    return {
+        status: response.status,
+        body: value,
+        serverTiming: response.headers.get("server-timing") ?? undefined,
+    };
 }
 function responseFromReply(reply) {
     return Response.json(reply.body, {
@@ -79,16 +67,14 @@ function boundedMessage(text) {
  * Carry it, bounded, into the terminal channel_dispatch_failed so the
  * control plane's failure log is diagnosable.
  */
-function channelDispatchDetail(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const text = (yield response.text()).trim();
-            return text === "" ? undefined : boundedMessage(text);
-        }
-        catch (_a) {
-            return undefined;
-        }
-    });
+async function channelDispatchDetail(response) {
+    try {
+        const text = (await response.text()).trim();
+        return text === "" ? undefined : boundedMessage(text);
+    }
+    catch {
+        return undefined;
+    }
 }
 function terminalHostedError(status, error, message) {
     return hostedGuestErrorResponse({
@@ -160,18 +146,16 @@ function mappedAdmissionFailure(error) {
  * Dispatch is the adapter the mounted channel attached. Hosted delivery
  * does not switch on `channelKind`.
  */
-export function dispatchHostedAdmission(input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const adapter = getHostedAdmissionAdapter(input.definition);
-        if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
-            return {
-                response: terminalHostedError(422, "channel_kind_mismatch"),
-            };
-        }
-        // The admission window marker follows the async graph into task bodies so
-        // the engine can refuse local sends that would bypass the capture stub.
-        return runDuringHostedAdmission(() => runAdmission(input, adapter));
-    });
+export async function dispatchHostedAdmission(input) {
+    const adapter = getHostedAdmissionAdapter(input.definition);
+    if (adapter === undefined || adapter.kind !== input.delivery.channelKind) {
+        return {
+            response: terminalHostedError(422, "channel_kind_mismatch"),
+        };
+    }
+    // The admission window marker follows the async graph into task bodies so
+    // the engine can refuse local sends that would bypass the capture stub.
+    return runDuringHostedAdmission(() => runAdmission(input, adapter));
 }
 /**
  * Reserved reminder admission: parse the compact payload and invoke
@@ -179,42 +163,14 @@ export function dispatchHostedAdmission(input) {
  * `skip`) and never opens the send-capture / model-session path here —
  * prompt-form fires still follow up inside the runner.
  */
-function dispatchHostedReminderAdmission(input, delivery) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const descriptor = parseHostedReminderFireDescriptorPayload(delivery.payload);
-        if (descriptor !== undefined) {
-            if (input.executeReminderDescriptor === undefined) {
-                return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder CP executor wired for hosted admission.");
-            }
-            try {
-                const result = yield input.executeReminderDescriptor(descriptor);
-                const outcome = result.outcome === "noop" ? "skip" : "task";
-                return Response.json({
-                    ok: true,
-                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                    outcome,
-                });
-            }
-            catch (error) {
-                if (error instanceof UnknownReminderError) {
-                    return terminalHostedError(404, "unknown_reminder", boundedMessage(error.message));
-                }
-                if (error instanceof ReminderValidationError) {
-                    return terminalHostedError(400, "invalid_reminder", boundedMessage(error.message));
-                }
-                // Transient CP apply/fetch failures must remain retryable.
-                throw error;
-            }
-        }
-        if (input.fireReminder === undefined) {
-            return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder runner wired for hosted admission.");
-        }
-        const payload = parseHostedReminderFirePayload(delivery.payload);
-        if (payload === undefined) {
-            return terminalHostedError(400, "invalid_reminder_payload", "Expected reminder descriptor or legacy payload { reminderId, fireCount }.");
+async function dispatchHostedReminderAdmission(input, delivery) {
+    const descriptor = parseHostedReminderFireDescriptorPayload(delivery.payload);
+    if (descriptor !== undefined) {
+        if (input.executeReminderDescriptor === undefined) {
+            return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder CP executor wired for hosted admission.");
         }
         try {
-            const result = yield input.fireReminder(payload.reminderId, payload.fireCount);
+            const result = await input.executeReminderDescriptor(descriptor);
             const outcome = result.outcome === "noop" ? "skip" : "task";
             return Response.json({
                 ok: true,
@@ -229,114 +185,143 @@ function dispatchHostedReminderAdmission(input, delivery) {
             if (error instanceof ReminderValidationError) {
                 return terminalHostedError(400, "invalid_reminder", boundedMessage(error.message));
             }
+            // Transient CP apply/fetch failures must remain retryable.
             throw error;
         }
-    });
-}
-function runAdmission(input, adapter) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        var _b;
-        const background = [];
-        let captured;
-        const capturingArgs = Object.assign(Object.assign({}, input.args), { send: (message_1, ...args_1) => __awaiter(this, [message_1, ...args_1], void 0, function* (message, options = {}) {
-                if (captured !== undefined) {
-                    throw new HostedSendLimitExceeded();
-                }
-                captured = { message, options };
-                return createDeferredChannelSession();
-            }), waitUntil: promise => {
-                background.push(promise);
-            } });
-        const args = (_b = (_a = adapter.prepareArgs) === null || _a === void 0 ? void 0 : _a.call(adapter, capturingArgs)) !== null && _b !== void 0 ? _b : capturingArgs;
-        let dispatched;
-        try {
-            dispatched = yield adapter.dispatch({
-                channelId: input.delivery.channelId,
-                eventType: input.delivery.eventType,
-                payload: input.delivery.payload,
-                deliveryId: input.delivery.deliveryId,
-                args,
-                mailboxContinuationKey: input.delivery.mailboxContinuationKey,
-                platformHandoff: input.delivery.platformHandoff,
-            });
-        }
-        catch (error) {
-            const mapped = mappedAdmissionFailure(error);
-            if (mapped !== undefined) {
-                return mapped;
-            }
-            return {
-                response: terminalHostedError(500, "agent_admission_threw", boundedMessage(error instanceof Error ? error.message : String(error))),
-            };
-        }
-        if (!dispatched.ok) {
-            return {
-                response: terminalHostedError(dispatched.status >= 400 ? dispatched.status : 502, "channel_dispatch_failed", yield channelDispatchDetail(dispatched)),
-            };
+    }
+    if (input.fireReminder === undefined) {
+        return transientHostedError(503, "reminder_dispatch_unavailable", "This guest has no reminder runner wired for hosted admission.");
+    }
+    const payload = parseHostedReminderFirePayload(delivery.payload);
+    if (payload === undefined) {
+        return terminalHostedError(400, "invalid_reminder_payload", "Expected reminder descriptor or legacy payload { reminderId, fireCount }.");
+    }
+    try {
+        const result = await input.fireReminder(payload.reminderId, payload.fireCount);
+        const outcome = result.outcome === "noop" ? "skip" : "task";
+        return Response.json({
+            ok: true,
+            v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+            outcome,
+        });
+    }
+    catch (error) {
+        if (error instanceof UnknownReminderError) {
+            return terminalHostedError(404, "unknown_reminder", boundedMessage(error.message));
         }
-        try {
-            yield Promise.all(background);
+        if (error instanceof ReminderValidationError) {
+            return terminalHostedError(400, "invalid_reminder", boundedMessage(error.message));
         }
-        catch (error) {
-            const mapped = mappedAdmissionFailure(error);
-            if (mapped !== undefined) {
-                return mapped;
+        throw error;
+    }
+}
+async function runAdmission(input, adapter) {
+    const background = [];
+    let captured;
+    const capturingArgs = {
+        ...input.args,
+        send: async (message, options = {}) => {
+            if (captured !== undefined) {
+                throw new HostedSendLimitExceeded();
             }
-            return {
-                response: terminalHostedError(503, "background_dispatch_failed", boundedMessage(error instanceof Error ? error.message : String(error))),
-            };
-        }
-        if (captured !== undefined) {
-            return {
-                response: Response.json({
-                    ok: true,
-                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                    outcome: "send",
-                }),
-                pendingSend: {
-                    channelId: input.delivery.channelId,
-                    message: captured.message,
-                    options: captured.options,
-                    mailboxContinuationKey: input.delivery.mailboxContinuationKey,
-                },
-            };
+            captured = { message, options };
+            return createDeferredChannelSession();
+        },
+        waitUntil: promise => {
+            background.push(promise);
+        },
+    };
+    const args = adapter.prepareArgs?.(capturingArgs) ?? capturingArgs;
+    let dispatched;
+    try {
+        dispatched = await adapter.dispatch({
+            channelId: input.delivery.channelId,
+            eventType: input.delivery.eventType,
+            payload: input.delivery.payload,
+            deliveryId: input.delivery.deliveryId,
+            args,
+            mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+            platformHandoff: input.delivery.platformHandoff,
+        });
+    }
+    catch (error) {
+        const mapped = mappedAdmissionFailure(error);
+        if (mapped !== undefined) {
+            return mapped;
         }
-        // A "send" tag with nothing captured means the channel's send bypassed the
-        // capture stub, so there is nothing for the control plane to execute.
-        const outcome = dispatchOutcome(dispatched);
-        if (outcome === undefined || outcome === "send") {
-            return {
-                response: terminalHostedError(502, "channel_outcome_missing"),
-            };
+        return {
+            response: terminalHostedError(500, "agent_admission_threw", boundedMessage(error instanceof Error ? error.message : String(error))),
+        };
+    }
+    if (!dispatched.ok) {
+        return {
+            response: terminalHostedError(dispatched.status >= 400 ? dispatched.status : 502, "channel_dispatch_failed", await channelDispatchDetail(dispatched)),
+        };
+    }
+    try {
+        await Promise.all(background);
+    }
+    catch (error) {
+        const mapped = mappedAdmissionFailure(error);
+        if (mapped !== undefined) {
+            return mapped;
         }
-        const rejection = outcome === "skip" ? yield handlerRejection(dispatched) : undefined;
         return {
-            response: Response.json(Object.assign({ ok: true, v: HOSTED_DELIVERY_PROTOCOL_VERSION, outcome }, (rejection === undefined ? {} : { rejection, engineVersion: packageVersion() }))),
+            response: terminalHostedError(503, "background_dispatch_failed", boundedMessage(error instanceof Error ? error.message : String(error))),
         };
-    });
+    }
+    if (captured !== undefined) {
+        return {
+            response: Response.json({
+                ok: true,
+                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                outcome: "send",
+            }),
+            pendingSend: {
+                channelId: input.delivery.channelId,
+                message: captured.message,
+                options: captured.options,
+                mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+            },
+        };
+    }
+    // A "send" tag with nothing captured means the channel's send bypassed the
+    // capture stub, so there is nothing for the control plane to execute.
+    const outcome = dispatchOutcome(dispatched);
+    if (outcome === undefined || outcome === "send") {
+        return {
+            response: terminalHostedError(502, "channel_outcome_missing"),
+        };
+    }
+    const rejection = outcome === "skip" ? await handlerRejection(dispatched) : undefined;
+    return {
+        response: Response.json({
+            ok: true,
+            v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+            outcome,
+            ...(rejection === undefined ? {} : { rejection, engineVersion: packageVersion() }),
+        }),
+    };
 }
 /** Handler 4xx on a skip. Benign skips (nothing to do) have no status. */
-function handlerRejection(response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const body = (yield response.clone().json());
-            if (typeof body !== "object" || body === null || Array.isArray(body)) {
-                return undefined;
-            }
-            const record = body;
-            if (record.skipped !== true) {
-                return undefined;
-            }
-            return parseHostedAdmissionHandlerRejection({
-                reason: record.reason,
-                status: record.status,
-            });
+async function handlerRejection(response) {
+    try {
+        const body = (await response.clone().json());
+        if (typeof body !== "object" || body === null || Array.isArray(body)) {
+            return undefined;
         }
-        catch (_a) {
+        const record = body;
+        if (record.skipped !== true) {
             return undefined;
         }
-    });
+        return parseHostedAdmissionHandlerRejection({
+            reason: record.reason,
+            status: record.status,
+        });
+    }
+    catch {
+        return undefined;
+    }
 }
 function withServerTiming(response, durationMs, guestNetwork, latency) {
     const parts = [`agent_sdk;desc="hosted";dur=${Math.max(0, durationMs).toFixed(1)}`];
@@ -391,15 +376,14 @@ function logGuestNetworkWait(phase, stats) {
     console.info(`[bdk] guest network ${stats.outcome} phase=${phase} waitMs=${String(stats.waitMs)} probes=${String(stats.probeAttempts)}`);
 }
 export function registerHostedDeliveryRoute(input) {
-    var _a, _b;
     const pending = new Map();
     const admissions = new Map();
     const activeOwners = new Map();
-    const pendingTtlMs = 10 * 60000;
+    const pendingTtlMs = 10 * 60_000;
     /** Keep an in-flight owner turn addressable for status polls. */
-    const ownerTurnPendingTtlMs = 12 * 60 * 60000;
-    const waitForNetwork = (_a = input.waitForGuestNetwork) !== null && _a !== void 0 ? _a : (() => waitForGuestNetworkReady());
-    const consumeBoundSecrets = (_b = input.consumeBoundSecrets) !== null && _b !== void 0 ? _b : (() => consumeHostedBoundSecrets());
+    const ownerTurnPendingTtlMs = 12 * 60 * 60_000;
+    const waitForNetwork = input.waitForGuestNetwork ?? (() => waitForGuestNetworkReady());
+    const consumeBoundSecrets = input.consumeBoundSecrets ?? (() => consumeHostedBoundSecrets());
     /**
      * Close the bind-file handoff before anything else touches the request.
      * A surviving secret is retryable: the control plane re-binds and the next
@@ -411,9 +395,9 @@ export function registerHostedDeliveryRoute(input) {
             ? undefined
             : transientHostedError(503, consumed.code, boundedMessage(consumed.message));
     };
-    const finishNetworkWait = (phase) => __awaiter(this, void 0, void 0, function* () {
+    const finishNetworkWait = async (phase) => {
         try {
-            const timing = guestNetworkStatsFromWait(yield waitForNetwork());
+            const timing = guestNetworkStatsFromWait(await waitForNetwork());
             logGuestNetworkWait(phase, timing);
             return { timing };
         }
@@ -430,7 +414,7 @@ export function registerHostedDeliveryRoute(input) {
                 response: transientHostedError(503, GUEST_NETWORK_UNAVAILABLE, boundedMessage(message)),
             };
         }
-    });
+    };
     const pruneExpired = () => {
         const now = Date.now();
         for (const [token, item] of pending) {
@@ -444,50 +428,48 @@ export function registerHostedDeliveryRoute(input) {
             }
         }
     };
-    const runAdmissionOperation = (delivery, definition) => __awaiter(this, void 0, void 0, function* () {
-        return afterHostedWork(input.flushOtel, () => __awaiter(this, void 0, void 0, function* () {
-            const startedAt = performance.now();
-            let guestNetwork;
-            const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork);
-            try {
-                const network = yield finishNetworkWait("admission");
-                guestNetwork = network.timing;
-                if (network.response !== undefined) {
-                    return yield responseToReply(finish(network.response));
-                }
-                if (isHostedReminderAdmission(delivery)) {
-                    return yield responseToReply(finish(yield dispatchHostedReminderAdmission(input, delivery)));
-                }
-                if (definition === undefined) {
-                    return yield responseToReply(finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`)));
-                }
-                const admitted = yield dispatchHostedAdmission({
-                    delivery,
-                    definition,
-                    args: input.buildHandlerArgs(delivery.channelId),
-                });
-                if (admitted.pendingSend === undefined) {
-                    return yield responseToReply(finish(admitted.response));
-                }
-                pruneExpired();
-                const admissionToken = randomBytes(24).toString("hex");
-                pending.set(admissionToken, {
-                    send: admitted.pendingSend,
-                    channelKind: delivery.channelKind,
-                    expiresAt: Date.now() + pendingTtlMs,
-                    deliveryId: delivery.deliveryId,
-                });
-                return yield responseToReply(finish(Response.json({
-                    ok: true,
-                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                    outcome: "send",
-                    admissionToken,
-                })));
+    const runAdmissionOperation = async (delivery, definition) => afterHostedWork(input.flushOtel, async () => {
+        const startedAt = performance.now();
+        let guestNetwork;
+        const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork);
+        try {
+            const network = await finishNetworkWait("admission");
+            guestNetwork = network.timing;
+            if (network.response !== undefined) {
+                return await responseToReply(finish(network.response));
+            }
+            if (isHostedReminderAdmission(delivery)) {
+                return await responseToReply(finish(await dispatchHostedReminderAdmission(input, delivery)));
+            }
+            if (definition === undefined) {
+                return await responseToReply(finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`)));
             }
-            catch (error) {
-                return yield responseToReply(finish(terminalHostedError(503, "internal_error", boundedMessage(error instanceof Error ? error.message : String(error)))));
+            const admitted = await dispatchHostedAdmission({
+                delivery,
+                definition,
+                args: input.buildHandlerArgs(delivery.channelId),
+            });
+            if (admitted.pendingSend === undefined) {
+                return await responseToReply(finish(admitted.response));
             }
-        }));
+            pruneExpired();
+            const admissionToken = randomBytes(24).toString("hex");
+            pending.set(admissionToken, {
+                send: admitted.pendingSend,
+                channelKind: delivery.channelKind,
+                expiresAt: Date.now() + pendingTtlMs,
+                deliveryId: delivery.deliveryId,
+            });
+            return await responseToReply(finish(Response.json({
+                ok: true,
+                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                outcome: "send",
+                admissionToken,
+            })));
+        }
+        catch (error) {
+            return await responseToReply(finish(terminalHostedError(503, "internal_error", boundedMessage(error instanceof Error ? error.message : String(error)))));
+        }
     });
     // Hosted callers reach this only through Anyrun's signed pod-port URL.
     // The marker is a second, route-specific fence distinct from channel auth.
@@ -505,86 +487,83 @@ export function registerHostedDeliveryRoute(input) {
         method: "POST",
         pattern: `${input.base}${HOSTED_ADMISSION_PATH}`,
         auth: [auth],
-        handler: (request) => __awaiter(this, void 0, void 0, function* () {
-            return afterHostedWork(input.flushOtel, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const startedAt = performance.now();
-                const finish = (response) => withServerTiming(response, performance.now() - startedAt);
-                const unconsumed = finishBoundSecrets();
-                if (unconsumed !== undefined) {
-                    return finish(unconsumed);
+        handler: async (request) => afterHostedWork(input.flushOtel, async () => {
+            const startedAt = performance.now();
+            const finish = (response) => withServerTiming(response, performance.now() - startedAt);
+            const unconsumed = finishBoundSecrets();
+            if (unconsumed !== undefined) {
+                return finish(unconsumed);
+            }
+            const rawAdmission = await readJsonObject(request);
+            const delivery = parseHostedAdmission(rawAdmission);
+            if (delivery === undefined) {
+                const rawKeys = typeof rawAdmission === "object" &&
+                    rawAdmission !== null &&
+                    !Array.isArray(rawAdmission)
+                    ? Object.keys(rawAdmission)
+                    : [];
+                console.info(`[bdk] hosted admission rejected: envelope failed to parse keys=${JSON.stringify(rawKeys)} hasManagedAutomation=${String(rawKeys.includes("managedAutomation"))}`);
+                return finish(terminalHostedError(400, "invalid_hosted_admission", "Expected a supported Agent SDK hosted-admission envelope."));
+            }
+            pruneExpired();
+            const existing = admissions.get(delivery.deliveryId);
+            if (delivery.mode === "status") {
+                if (existing === undefined) {
+                    return finish(transientHostedError(409, "hosted_admission_unavailable", "No hosted admission is in flight for this delivery."));
                 }
-                const rawAdmission = yield readJsonObject(request);
-                const delivery = parseHostedAdmission(rawAdmission);
-                if (delivery === undefined) {
-                    const rawKeys = typeof rawAdmission === "object" &&
-                        rawAdmission !== null &&
-                        !Array.isArray(rawAdmission)
-                        ? Object.keys(rawAdmission)
-                        : [];
-                    console.info(`[bdk] hosted admission rejected: envelope failed to parse keys=${JSON.stringify(rawKeys)} hasManagedAutomation=${String(rawKeys.includes("managedAutomation"))}`);
-                    return finish(terminalHostedError(400, "invalid_hosted_admission", "Expected a supported Agent SDK hosted-admission envelope."));
+                return existing.settledReply === undefined
+                    ? finish(Response.json({
+                        ok: true,
+                        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                        outcome: "running",
+                    }))
+                    : responseFromReply(existing.settledReply);
+            }
+            if (existing !== undefined) {
+                if (existing.settledReply !== undefined && isTransientRetryReply(existing.settledReply)) {
+                    admissions.delete(delivery.deliveryId);
                 }
-                pruneExpired();
-                const existing = admissions.get(delivery.deliveryId);
-                if (delivery.mode === "status") {
-                    if (existing === undefined) {
-                        return finish(transientHostedError(409, "hosted_admission_unavailable", "No hosted admission is in flight for this delivery."));
-                    }
+                else {
                     return existing.settledReply === undefined
                         ? finish(Response.json({
                             ok: true,
                             v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                            outcome: "running",
+                            outcome: "started",
                         }))
                         : responseFromReply(existing.settledReply);
                 }
-                if (existing !== undefined) {
-                    if (existing.settledReply !== undefined && isTransientRetryReply(existing.settledReply)) {
-                        admissions.delete(delivery.deliveryId);
-                    }
-                    else {
-                        return existing.settledReply === undefined
-                            ? finish(Response.json({
-                                ok: true,
-                                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                                outcome: "started",
-                            }))
-                            : responseFromReply(existing.settledReply);
-                    }
-                }
-                console.info(`[bdk] hosted admission received deliveryId=${delivery.deliveryId} channelId=${delivery.channelId} channelKind=${delivery.channelKind} eventType=${delivery.eventType} sessionMode=${delivery.sessionMode} managedAutomation=${delivery.managedAutomation === undefined ? "<absent>" : `automationUuid=${delivery.managedAutomation.automationUuid} mcpServerNames=${String(delivery.managedAutomation.mcpServerNames.length)} slackChannels=${delivery.managedAutomation.slackChannels === undefined ? "<absent>" : JSON.stringify(delivery.managedAutomation.slackChannels)}`}`);
-                recordHostedManagedAutomation(delivery);
-                const reminder = isHostedReminderAdmission(delivery);
-                const definition = reminder
-                    ? undefined
-                    : (_a = input.channels.find(candidate => candidate.id === delivery.channelId)) === null || _a === void 0 ? void 0 : _a.definition;
-                if (!reminder && definition === undefined) {
-                    return finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`));
-                }
-                let operation;
-                const execution = runAdmissionOperation(delivery, definition).then(reply => {
-                    operation.settledReply = reply;
-                    operation.expiresAt = Date.now() + pendingTtlMs;
-                    return reply;
-                });
-                operation = {
-                    execution,
-                    expiresAt: Date.now() + ownerTurnPendingTtlMs,
-                };
-                admissions.set(delivery.deliveryId, operation);
-                const quickReply = yield Promise.race([
-                    execution,
-                    new Promise(resolve => setImmediate(() => resolve(undefined))),
-                ]);
-                if (quickReply !== undefined) {
-                    return responseFromReply(quickReply);
-                }
-                return finish(Response.json({
-                    ok: true,
-                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                    outcome: "started",
-                }));
+            }
+            console.info(`[bdk] hosted admission received deliveryId=${delivery.deliveryId} channelId=${delivery.channelId} channelKind=${delivery.channelKind} eventType=${delivery.eventType} sessionMode=${delivery.sessionMode} managedAutomation=${delivery.managedAutomation === undefined ? "<absent>" : `automationUuid=${delivery.managedAutomation.automationUuid} mcpServerNames=${String(delivery.managedAutomation.mcpServerNames.length)} slackChannels=${delivery.managedAutomation.slackChannels === undefined ? "<absent>" : JSON.stringify(delivery.managedAutomation.slackChannels)}`}`);
+            recordHostedManagedAutomation(delivery);
+            const reminder = isHostedReminderAdmission(delivery);
+            const definition = reminder
+                ? undefined
+                : input.channels.find(candidate => candidate.id === delivery.channelId)?.definition;
+            if (!reminder && definition === undefined) {
+                return finish(terminalHostedError(404, "channel_not_found", `No channel named "${delivery.channelId}" is mounted.`));
+            }
+            let operation;
+            const execution = runAdmissionOperation(delivery, definition).then(reply => {
+                operation.settledReply = reply;
+                operation.expiresAt = Date.now() + pendingTtlMs;
+                return reply;
+            });
+            operation = {
+                execution,
+                expiresAt: Date.now() + ownerTurnPendingTtlMs,
+            };
+            admissions.set(delivery.deliveryId, operation);
+            const quickReply = await Promise.race([
+                execution,
+                new Promise(resolve => setImmediate(() => resolve(undefined))),
+            ]);
+            if (quickReply !== undefined) {
+                return responseFromReply(quickReply);
+            }
+            return finish(Response.json({
+                ok: true,
+                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                outcome: "started",
             }));
         }),
     });
@@ -592,303 +571,356 @@ export function registerHostedDeliveryRoute(input) {
         method: "POST",
         pattern: `${input.base}${HOSTED_EXECUTION_PATH}`,
         auth: [auth],
-        handler: (request) => __awaiter(this, void 0, void 0, function* () {
-            return afterHostedWork(input.flushOtel, () => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const startedAt = performance.now();
-                let guestNetwork;
-                let latencySnapshot;
-                const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork, latencySnapshot);
-                const unconsumed = finishBoundSecrets();
-                if (unconsumed !== undefined) {
-                    return finish(unconsumed);
-                }
-                const execution = parseHostedExecution(yield readJsonObject(request));
-                if (execution === undefined) {
-                    return finish(terminalHostedError(400, "invalid_hosted_execution", "Expected a supported Agent SDK hosted-execution envelope."));
-                }
-                pruneExpired();
-                const admitted = pending.get(execution.admissionToken);
-                if (admitted === undefined) {
-                    return finish(transientHostedError(409, "hosted_admission_unavailable", "The hosted admission token is missing or expired."));
-                }
-                if (admitted.sessionPublicId !== undefined &&
-                    admitted.sessionPublicId !== execution.sessionPublicId) {
-                    return finish(transientHostedError(409, "hosted_admission_session_mismatch", "The hosted admission token is already bound to another session."));
+        handler: async (request) => afterHostedWork(input.flushOtel, async () => {
+            const startedAt = performance.now();
+            let guestNetwork;
+            let latencySnapshot;
+            const finish = (response) => withServerTiming(response, performance.now() - startedAt, guestNetwork, latencySnapshot);
+            const unconsumed = finishBoundSecrets();
+            if (unconsumed !== undefined) {
+                return finish(unconsumed);
+            }
+            const execution = parseHostedExecution(await readJsonObject(request));
+            if (execution === undefined) {
+                return finish(terminalHostedError(400, "invalid_hosted_execution", "Expected a supported Agent SDK hosted-execution envelope."));
+            }
+            pruneExpired();
+            const admitted = pending.get(execution.admissionToken);
+            if (admitted === undefined) {
+                return finish(transientHostedError(409, "hosted_admission_unavailable", "The hosted admission token is missing or expired."));
+            }
+            if (admitted.sessionPublicId !== undefined &&
+                admitted.sessionPublicId !== execution.sessionPublicId) {
+                return finish(transientHostedError(409, "hosted_admission_session_mismatch", "The hosted admission token is already bound to another session."));
+            }
+            if (execution.mode === "start" &&
+                admitted.settledReply !== undefined &&
+                isTransientRetryReply(admitted.settledReply)) {
+                delete admitted.settledReply;
+                delete admitted.execution;
+            }
+            if (execution.mode === "status" ||
+                (execution.mode === "start" && admitted.execution !== undefined)) {
+                if (admitted.settledReply !== undefined) {
+                    return responseFromReply(admitted.settledReply);
                 }
-                if (execution.mode === "start" &&
-                    admitted.settledReply !== undefined &&
-                    isTransientRetryReply(admitted.settledReply)) {
-                    delete admitted.settledReply;
-                    delete admitted.execution;
+                if (admitted.execution === undefined) {
+                    return finish(transientHostedError(409, "hosted_admission_unavailable", "The hosted admission token has no owner turn in flight."));
                 }
-                if (execution.mode === "status" ||
-                    (execution.mode === "start" && admitted.execution !== undefined)) {
-                    if (admitted.settledReply !== undefined) {
-                        return responseFromReply(admitted.settledReply);
-                    }
-                    if (admitted.execution === undefined) {
-                        return finish(transientHostedError(409, "hosted_admission_unavailable", "The hosted admission token has no owner turn in flight."));
-                    }
-                    if (execution.mode === "start") {
-                        return finish(Response.json({
-                            ok: true,
-                            v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                            outcome: "started",
-                        }));
-                    }
+                if (execution.mode === "start") {
                     return finish(Response.json({
                         ok: true,
                         v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                        outcome: "running",
+                        outcome: "started",
                     }));
                 }
-                admitted.sessionPublicId = execution.sessionPublicId;
-                if (execution.mode === "enqueue") {
-                    const network = yield finishNetworkWait("execution");
-                    guestNetwork = network.timing;
-                    if (network.response !== undefined) {
-                        return finish(network.response);
-                    }
-                    const enqueueOutcome = yield enqueueIntoActiveOwner({
-                        activeOwners,
-                        sessionPublicId: execution.sessionPublicId,
-                        deliveryId: admitted.deliveryId,
-                        send: admitted.send,
-                        buildHandlerArgs: input.buildHandlerArgs,
-                    });
-                    return finish(Response.json(Object.assign({ ok: true, v: HOSTED_DELIVERY_PROTOCOL_VERSION }, enqueueOutcome)));
+                return finish(Response.json({
+                    ok: true,
+                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                    outcome: "running",
+                }));
+            }
+            admitted.sessionPublicId = execution.sessionPublicId;
+            if (execution.mode === "enqueue") {
+                const network = await finishNetworkWait("execution");
+                guestNetwork = network.timing;
+                if (network.response !== undefined) {
+                    return finish(network.response);
                 }
-                if (admitted.execution === undefined) {
-                    admitted.expiresAt = Date.now() + ownerTurnPendingTtlMs;
+                const enqueueOutcome = await enqueueIntoActiveOwner({
+                    activeOwners,
+                    sessionPublicId: execution.sessionPublicId,
+                    deliveryId: admitted.deliveryId,
+                    send: admitted.send,
+                    buildHandlerArgs: input.buildHandlerArgs,
+                });
+                return finish(Response.json({
+                    ok: true,
+                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                    ...enqueueOutcome,
+                }));
+            }
+            if (admitted.execution === undefined) {
+                admitted.expiresAt = Date.now() + ownerTurnPendingTtlMs;
+            }
+            admitted.execution ??= afterHostedWork(input.flushOtel, async () => {
+                const network = await finishNetworkWait("execution");
+                guestNetwork = network.timing;
+                if (network.response !== undefined) {
+                    return await responseToReply(finish(network.response));
                 }
-                (_a = admitted.execution) !== null && _a !== void 0 ? _a : (admitted.execution = afterHostedWork(input.flushOtel, () => __awaiter(this, void 0, void 0, function* () {
-                    const network = yield finishNetworkWait("execution");
-                    guestNetwork = network.timing;
-                    if (network.response !== undefined) {
-                        return yield responseToReply(finish(network.response));
-                    }
-                    const startedAt = performance.now();
-                    const executionId = hostedExecutionDiagId(execution.admissionToken);
-                    const sinks = Object.assign(Object.assign(Object.assign(Object.assign({}, (input.stateRoot === undefined ? {} : { stateRoot: input.stateRoot })), (input.persistSessionRun === undefined
+                const startedAt = performance.now();
+                const executionId = hostedExecutionDiagId(execution.admissionToken);
+                const sinks = {
+                    ...(input.stateRoot === undefined ? {} : { stateRoot: input.stateRoot }),
+                    ...(input.persistSessionRun === undefined
                         ? {}
-                        : { persistSessionRun: input.persistSessionRun })), (input.flushStartLog === undefined ? {} : { flushStartLog: input.flushStartLog })), (input.snapshotLogs === undefined ? {} : { snapshotLogs: input.snapshotLogs }));
-                    const writeDiag = (fields) => __awaiter(this, void 0, void 0, function* () {
-                        const classification = fields.failureCode === undefined
-                            ? undefined
-                            : hostedFailureClassification(fields.failureCode);
-                        yield flushHostedExecutionRecord(sinks, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ executionId, sessionPublicId: execution.sessionPublicId, sessionId: fields.sessionId, turnStatus: fields.turnStatus, durationMs: Math.max(0, Math.round(performance.now() - startedAt)) }, (fields.message === undefined ? {} : { message: fields.message })), (fields.abortReason === undefined ? {} : { abortReason: fields.abortReason })), { failureCode: fields.failureCode }), (fields.errorCode === undefined ? {} : { errorCode: fields.errorCode })), { classification }), (fields.error === undefined ? {} : { error: fields.error })));
-                    });
-                    // Claim the file before the turn runs. If a later status request
-                    // fails, the host reads this record while the turn may still be
-                    // running; the marker prevents it from surfacing the previous
-                    // delivery's terminal record.
-                    yield writeDiag({
-                        sessionId: "",
-                        turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                        : { persistSessionRun: input.persistSessionRun }),
+                    ...(input.flushStartLog === undefined ? {} : { flushStartLog: input.flushStartLog }),
+                    ...(input.snapshotLogs === undefined ? {} : { snapshotLogs: input.snapshotLogs }),
+                };
+                const writeDiag = async (fields) => {
+                    const classification = fields.failureCode === undefined
+                        ? undefined
+                        : hostedFailureClassification(fields.failureCode);
+                    await flushHostedExecutionRecord(sinks, {
+                        executionId,
+                        sessionPublicId: execution.sessionPublicId,
+                        sessionId: fields.sessionId,
+                        turnStatus: fields.turnStatus,
+                        durationMs: Math.max(0, Math.round(performance.now() - startedAt)),
+                        ...(fields.message === undefined ? {} : { message: fields.message }),
+                        ...(fields.abortReason === undefined ? {} : { abortReason: fields.abortReason }),
+                        failureCode: fields.failureCode,
+                        ...(fields.errorCode === undefined ? {} : { errorCode: fields.errorCode }),
+                        classification,
+                        ...(fields.error === undefined ? {} : { error: fields.error }),
                     });
-                    let sessionId = "";
-                    const owner = {
-                        primaryDeliveryId: admitted.deliveryId,
-                        acceptedDeliveryIds: [],
-                        accepting: true,
-                        inflightInjects: new Set(),
-                        enqueueResults: new Map(),
-                    };
-                    activeOwners.set(execution.sessionPublicId, owner);
-                    return yield runWithHostedExecutionLatency({ channelKind: admitted.channelKind }, () => __awaiter(this, void 0, void 0, function* () {
-                        var _a;
-                        let completionAt;
-                        let drainAt;
-                        try {
-                            const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
-                            const session = yield args.send(admitted.send.message, Object.assign(Object.assign({}, admitted.send.options), { mailboxContinuation: {
-                                    key: admitted.send.mailboxContinuationKey,
-                                } }));
-                            sessionId = session.id;
-                            // The pre-turn claim used an empty sessionId. Stamp the
-                            // engine id now so a dashboard / session-view poll that
-                            // only has the factory `ses_…` can follow `session-events/`.
-                            yield writeDiag({
-                                sessionId,
-                                turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
-                            });
-                            const outcome = yield refreshStartLogWhile(sinks, execution.sessionPublicId, () => session.waitForCompletion());
-                            completionAt = hostedExecutionNow();
-                            // Status is the owner turn. waitForCompletion still waited
-                            // for any drained successor so this process is not parked
-                            // mid-follow-up; a successor failure must not 503-retry the
-                            // owner after satellites already ran.
-                            // Close acceptance at the turn boundary, before durability
-                            // work creates an idle-but-still-addressable window.
-                            owner.accepting = false;
-                            if (owner.inflightInjects.size > 0) {
-                                yield Promise.allSettled([...owner.inflightInjects]);
-                            }
-                            // Failed turns drain too: their record/continuation updates must
-                            // survive the park just like a finished turn's.
-                            yield (_a = input.drainSessionDurability) === null || _a === void 0 ? void 0 : _a.call(input, session.id);
-                            drainAt = hostedExecutionNow();
-                            const consumedDeliveryIds = [
-                                owner.primaryDeliveryId,
-                                ...owner.acceptedDeliveryIds,
-                            ];
-                            if (consumedDeliveryIds.length > HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
-                                throw new Error(`hosted execute consumedDeliveryIds length ${String(consumedDeliveryIds.length)} exceeds cap ${String(HOSTED_MAX_CONSUMED_DELIVERY_IDS)}`);
-                            }
-                            // Evict before the reply: TAS parks and hibernates this process
-                            // as soon as the POST returns. A leftover SDK handle freezes a
-                            // dead Connect/HTTP2 session that the next wake then reuses.
-                            evictHostedSdkSessions(input.evictSdkSession, session.id, execution.sessionPublicId);
-                            const hostedFailure = outcome.status === "finished"
-                                ? undefined
-                                : hostedFailureForUnfinishedTurn(outcome);
-                            yield writeDiag(Object.assign({ sessionId: session.id, turnStatus: outcome.status, message: outcome.errorMessage, abortReason: abortReasonFromTurnStatus(outcome.status, outcome.cancellationReason), failureCode: hostedFailure === null || hostedFailure === void 0 ? void 0 : hostedFailure.error }, (outcome.errorCode === undefined ? {} : { errorCode: outcome.errorCode })));
-                            const reply = hostedFailure !== undefined
-                                ? {
-                                    status: 503,
-                                    body: Object.assign({ ok: false, error: hostedFailure.error, retry: hostedFailure.retry, classification: hostedFailureClassification(hostedFailure.error), turnStatus: outcome.status, message: outcome.errorMessage }, (outcome.errorCode === undefined
-                                        ? {}
-                                        : { errorCode: outcome.errorCode })),
-                                }
-                                : {
-                                    status: 200,
-                                    body: {
-                                        ok: true,
-                                        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                                        outcome: "send",
-                                        consumedDeliveryIds,
-                                    },
-                                };
-                            // Finalize as late as possible so `post_drain` and `total`
-                            // include eviction + diag write after durability drain.
-                            latencySnapshot = finalizeHostedExecutionLatency({
-                                completionAt,
-                                drainAt,
-                                endedAt: hostedExecutionNow(),
+                };
+                // Claim the file before the turn runs. If a later status request
+                // fails, the host reads this record while the turn may still be
+                // running; the marker prevents it from surfacing the previous
+                // delivery's terminal record.
+                await writeDiag({
+                    sessionId: "",
+                    turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                });
+                let sessionId = "";
+                const owner = {
+                    primaryDeliveryId: admitted.deliveryId,
+                    acceptedDeliveryIds: [],
+                    accepting: true,
+                    inflightInjects: new Set(),
+                    enqueueResults: new Map(),
+                };
+                activeOwners.set(execution.sessionPublicId, owner);
+                return await runWithHostedExecutionLatency({ channelKind: admitted.channelKind }, async () => {
+                    let completionAt;
+                    let drainAt;
+                    try {
+                        const args = input.buildHandlerArgs(admitted.send.channelId, execution.sessionPublicId);
+                        const options = {
+                            ...admitted.send.options,
+                            mailboxContinuation: {
+                                key: admitted.send.mailboxContinuationKey,
+                            },
+                        };
+                        const session = input.startSend === undefined
+                            ? await args.send(admitted.send.message, options)
+                            : await input.startSend({
+                                args,
+                                message: admitted.send.message,
+                                options,
+                                sessionPublicId: execution.sessionPublicId,
                             });
-                            return yield responseToReply(finish(Response.json(reply.body, { status: reply.status })));
+                        sessionId = session.id;
+                        // The pre-turn claim used an empty sessionId. Stamp the
+                        // engine id now so a dashboard / session-view poll that
+                        // only has the factory `ses_…` can follow `session-events/`.
+                        await writeDiag({
+                            sessionId,
+                            turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
+                        });
+                        const outcome = await refreshStartLogWhile(sinks, execution.sessionPublicId, () => session.waitForCompletion());
+                        completionAt = hostedExecutionNow();
+                        // Status is the owner turn. waitForCompletion still waited
+                        // for any drained successor so this process is not parked
+                        // mid-follow-up; a successor failure must not 503-retry the
+                        // owner after satellites already ran.
+                        // Close acceptance at the turn boundary, before durability
+                        // work creates an idle-but-still-addressable window.
+                        owner.accepting = false;
+                        if (owner.inflightInjects.size > 0) {
+                            await Promise.allSettled([...owner.inflightInjects]);
                         }
-                        catch (error) {
-                            owner.accepting = false;
-                            if (owner.inflightInjects.size > 0) {
-                                yield Promise.allSettled([...owner.inflightInjects]);
-                            }
-                            evictHostedSdkSessions(input.evictSdkSession, sessionId, execution.sessionPublicId);
-                            const thrownErrorCode = describeErrorCode(error);
-                            yield writeDiag(Object.assign({ sessionId: "", turnStatus: "error", message: error instanceof Error ? error.message : String(error), abortReason: "execute_throw", failureCode: "internal_error", error }, (thrownErrorCode === undefined ? {} : { errorCode: thrownErrorCode })));
-                            const endedAt = hostedExecutionNow();
-                            // Preserve completion/drain marks when the failure happened
-                            // during post-drain work; otherwise collapse to endedAt.
-                            latencySnapshot = finalizeHostedExecutionLatency({
-                                completionAt: completionAt !== null && completionAt !== void 0 ? completionAt : endedAt,
-                                drainAt: drainAt !== null && drainAt !== void 0 ? drainAt : endedAt,
-                                endedAt,
-                            });
-                            throw error;
+                        // Failed turns drain too: their record/continuation updates must
+                        // survive the park just like a finished turn's.
+                        await input.drainSessionDurability?.(session.id);
+                        drainAt = hostedExecutionNow();
+                        const consumedDeliveryIds = [
+                            owner.primaryDeliveryId,
+                            ...owner.acceptedDeliveryIds,
+                        ];
+                        if (consumedDeliveryIds.length > HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
+                            throw new Error(`hosted execute consumedDeliveryIds length ${String(consumedDeliveryIds.length)} exceeds cap ${String(HOSTED_MAX_CONSUMED_DELIVERY_IDS)}`);
                         }
-                        finally {
-                            if (activeOwners.get(execution.sessionPublicId) === owner) {
-                                activeOwners.delete(execution.sessionPublicId);
+                        // Evict before the reply: TAS parks and hibernates this process
+                        // as soon as the POST returns. A leftover SDK handle freezes a
+                        // dead Connect/HTTP2 session that the next wake then reuses.
+                        evictHostedSdkSessions(input.evictSdkSession, session.id, execution.sessionPublicId);
+                        const hostedFailure = outcome.status === "finished"
+                            ? undefined
+                            : hostedFailureForUnfinishedTurn(outcome);
+                        await writeDiag({
+                            sessionId: session.id,
+                            turnStatus: outcome.status,
+                            message: outcome.errorMessage,
+                            abortReason: abortReasonFromTurnStatus(outcome.status, outcome.cancellationReason),
+                            failureCode: hostedFailure?.error,
+                            ...(outcome.errorCode === undefined ? {} : { errorCode: outcome.errorCode }),
+                        });
+                        const reply = hostedFailure !== undefined
+                            ? {
+                                status: 503,
+                                body: {
+                                    ok: false,
+                                    error: hostedFailure.error,
+                                    retry: hostedFailure.retry,
+                                    classification: hostedFailureClassification(hostedFailure.error),
+                                    turnStatus: outcome.status,
+                                    message: outcome.errorMessage,
+                                    ...(outcome.errorCode === undefined
+                                        ? {}
+                                        : { errorCode: outcome.errorCode }),
+                                },
                             }
+                            : {
+                                status: 200,
+                                body: {
+                                    ok: true,
+                                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                                    outcome: "send",
+                                    consumedDeliveryIds,
+                                },
+                            };
+                        // Finalize as late as possible so `post_drain` and `total`
+                        // include eviction + diag write after durability drain.
+                        latencySnapshot = finalizeHostedExecutionLatency({
+                            completionAt,
+                            drainAt,
+                            endedAt: hostedExecutionNow(),
+                        });
+                        return await responseToReply(finish(Response.json(reply.body, { status: reply.status })));
+                    }
+                    catch (error) {
+                        owner.accepting = false;
+                        if (owner.inflightInjects.size > 0) {
+                            await Promise.allSettled([...owner.inflightInjects]);
                         }
-                    }));
-                })).then(reply => {
-                    admitted.settledReply = reply;
-                    admitted.expiresAt = Date.now() + pendingTtlMs;
-                    return reply;
-                }, error => {
-                    admitted.settledReply = {
-                        status: 503,
-                        body: {
-                            ok: false,
-                            error: "internal_error",
-                            retry: HOSTED_GUEST_RETRY_TERMINAL,
-                            classification: hostedFailureClassification("internal_error"),
+                        evictHostedSdkSessions(input.evictSdkSession, sessionId, execution.sessionPublicId);
+                        const thrownErrorCode = describeErrorCode(error);
+                        await writeDiag({
+                            sessionId: "",
+                            turnStatus: "error",
                             message: error instanceof Error ? error.message : String(error),
-                        },
-                    };
-                    admitted.expiresAt = Date.now() + pendingTtlMs;
-                    return admitted.settledReply;
-                }));
-                if (execution.mode === "start") {
-                    const quickReply = yield Promise.race([
-                        admitted.execution,
-                        new Promise(resolve => setImmediate(() => resolve(undefined))),
-                    ]);
-                    if (quickReply !== undefined) {
-                        return responseFromReply(quickReply);
+                            abortReason: "execute_throw",
+                            failureCode: "internal_error",
+                            error,
+                            ...(thrownErrorCode === undefined ? {} : { errorCode: thrownErrorCode }),
+                        });
+                        const endedAt = hostedExecutionNow();
+                        // Preserve completion/drain marks when the failure happened
+                        // during post-drain work; otherwise collapse to endedAt.
+                        latencySnapshot = finalizeHostedExecutionLatency({
+                            completionAt: completionAt ?? endedAt,
+                            drainAt: drainAt ?? endedAt,
+                            endedAt,
+                        });
+                        throw error;
                     }
-                    return finish(Response.json({
-                        ok: true,
-                        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                        outcome: "started",
-                    }));
+                    finally {
+                        if (activeOwners.get(execution.sessionPublicId) === owner) {
+                            activeOwners.delete(execution.sessionPublicId);
+                        }
+                    }
+                });
+            }).then(reply => {
+                admitted.settledReply = reply;
+                admitted.expiresAt = Date.now() + pendingTtlMs;
+                return reply;
+            }, error => {
+                admitted.settledReply = {
+                    status: 503,
+                    body: {
+                        ok: false,
+                        error: "internal_error",
+                        retry: HOSTED_GUEST_RETRY_TERMINAL,
+                        classification: hostedFailureClassification("internal_error"),
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+                admitted.expiresAt = Date.now() + pendingTtlMs;
+                return admitted.settledReply;
+            });
+            if (execution.mode === "start") {
+                const quickReply = await Promise.race([
+                    admitted.execution,
+                    new Promise(resolve => setImmediate(() => resolve(undefined))),
+                ]);
+                if (quickReply !== undefined) {
+                    return responseFromReply(quickReply);
                 }
-                return finish(terminalHostedError(400, "invalid_hosted_execution", "Owner execution requires start or status mode."));
-            }));
+                return finish(Response.json({
+                    ok: true,
+                    v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+                    outcome: "started",
+                }));
+            }
+            return finish(terminalHostedError(400, "invalid_hosted_execution", "Owner execution requires start or status mode."));
         }),
     });
 }
-function enqueueIntoActiveOwner(input) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const owner = input.activeOwners.get(input.sessionPublicId);
-        if (owner === undefined || !owner.accepting) {
-            return { outcome: "not_active" };
+async function enqueueIntoActiveOwner(input) {
+    const owner = input.activeOwners.get(input.sessionPublicId);
+    if (owner === undefined || !owner.accepting) {
+        return { outcome: "not_active" };
+    }
+    const existing = owner.enqueueResults.get(input.deliveryId);
+    if (existing !== undefined) {
+        const shared = await existing;
+        if (shared.outcome === "enqueued" || shared.outcome === "not_active") {
+            return { outcome: shared.outcome };
         }
-        const existing = owner.enqueueResults.get(input.deliveryId);
-        if (existing !== undefined) {
-            const shared = yield existing;
-            if (shared.outcome === "enqueued" || shared.outcome === "not_active") {
-                return { outcome: shared.outcome };
+        return { outcome: "not_active" };
+    }
+    let resolveResult;
+    const resultPromise = new Promise(resolve => {
+        resolveResult = resolve;
+    });
+    owner.enqueueResults.set(input.deliveryId, resultPromise);
+    // Capacity includes the primary delivery id.
+    if (1 + owner.acceptedDeliveryIds.length >= HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
+        const outcome = { outcome: "not_active" };
+        resolveResult(outcome);
+        return outcome;
+    }
+    // Reserve before send so concurrent enqueues cannot oversubscribe.
+    owner.acceptedDeliveryIds.push(input.deliveryId);
+    const inject = (async () => {
+        try {
+            const args = input.buildHandlerArgs(input.send.channelId, input.sessionPublicId);
+            const enqueueOptions = {
+                ...input.send.options,
+                mailboxContinuation: {
+                    key: input.send.mailboxContinuationKey,
+                },
+                hostedEnqueueOnly: true,
+            };
+            const session = await args.send(input.send.message, enqueueOptions);
+            if (session.coalesced !== true) {
+                throw new HostedEnqueueNotActiveError(input.sessionPublicId);
             }
-            return { outcome: "not_active" };
+            resolveResult({ outcome: "enqueued" });
         }
-        let resolveResult;
-        const resultPromise = new Promise(resolve => {
-            resolveResult = resolve;
-        });
-        owner.enqueueResults.set(input.deliveryId, resultPromise);
-        // Capacity includes the primary delivery id.
-        if (1 + owner.acceptedDeliveryIds.length >= HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
-            const outcome = { outcome: "not_active" };
-            resolveResult(outcome);
-            return outcome;
-        }
-        // Reserve before send so concurrent enqueues cannot oversubscribe.
-        owner.acceptedDeliveryIds.push(input.deliveryId);
-        const inject = (() => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const args = input.buildHandlerArgs(input.send.channelId, input.sessionPublicId);
-                const enqueueOptions = Object.assign(Object.assign({}, input.send.options), { mailboxContinuation: {
-                        key: input.send.mailboxContinuationKey,
-                    }, hostedEnqueueOnly: true });
-                const session = yield args.send(input.send.message, enqueueOptions);
-                if (session.coalesced !== true) {
-                    throw new HostedEnqueueNotActiveError(input.sessionPublicId);
-                }
-                resolveResult({ outcome: "enqueued" });
+        catch (error) {
+            const idx = owner.acceptedDeliveryIds.lastIndexOf(input.deliveryId);
+            if (idx >= 0) {
+                owner.acceptedDeliveryIds.splice(idx, 1);
             }
-            catch (error) {
-                const idx = owner.acceptedDeliveryIds.lastIndexOf(input.deliveryId);
-                if (idx >= 0) {
-                    owner.acceptedDeliveryIds.splice(idx, 1);
-                }
-                resolveResult({ outcome: "not_active" });
-                if (!(error instanceof HostedEnqueueNotActiveError)) {
-                    console.warn(`[bdk] hosted enqueue inject failed deliveryId=${input.deliveryId}: ${error instanceof Error ? error.message : String(error)}`);
-                }
+            resolveResult({ outcome: "not_active" });
+            if (!(error instanceof HostedEnqueueNotActiveError)) {
+                console.warn(`[bdk] hosted enqueue inject failed deliveryId=${input.deliveryId}: ${error instanceof Error ? error.message : String(error)}`);
             }
-        }))();
-        owner.inflightInjects.add(inject);
-        try {
-            yield inject;
         }
-        finally {
-            owner.inflightInjects.delete(inject);
-        }
-        return yield resultPromise;
-    });
+    })();
+    owner.inflightInjects.add(inject);
+    try {
+        await inject;
+    }
+    finally {
+        owner.inflightInjects.delete(inject);
+    }
+    return await resultPromise;
 }
 function evictHostedSdkSessions(evict, ...ids) {
     if (evict === undefined) {
@@ -940,29 +972,27 @@ function hostedFailureForUnfinishedTurn(outcome) {
     }
     return { error: "turn_failed", retry: HOSTED_GUEST_RETRY_TERMINAL };
 }
-function afterHostedWork(flushOtel, work) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const result = yield work();
-            if (result instanceof Response) {
-                endActiveHttpSpan(result.status);
-            }
-            return result;
-        }
-        catch (error) {
-            const status = statusForThrownRequestError(error);
-            endActiveHttpSpan(status, status >= 500 ? error : undefined);
-            throw error;
+async function afterHostedWork(flushOtel, work) {
+    try {
+        const result = await work();
+        if (result instanceof Response) {
+            endActiveHttpSpan(result.status);
         }
-        finally {
-            if (flushOtel !== undefined) {
-                try {
-                    yield flushOtel();
-                }
-                catch (_a) {
-                    // Soft-fail: exporter failure must not change hosted HTTP.
-                }
+        return result;
+    }
+    catch (error) {
+        const status = statusForThrownRequestError(error);
+        endActiveHttpSpan(status, status >= 500 ? error : undefined);
+        throw error;
+    }
+    finally {
+        if (flushOtel !== undefined) {
+            try {
+                await flushOtel();
+            }
+            catch {
+                // Soft-fail: exporter failure must not change hosted HTTP.
             }
         }
-    });
+    }
 }