@cursor/july 0.1.108 → 0.1.111

package/src/internal/hosted-delivery-protocol.ts

@@ -257,17 +257,42 @@ export type HostedAdmissionOutcome =
   | { ok: true; v: 2; outcome: "skip" | "task" }
   | { ok: true; v: 2; outcome: "send"; admissionToken: string };
 
+/**
+ * Cap on delivery IDs an owner execute may report as consumed (primary +
+ * accepted active-guest enqueues). Enqueue requests beyond this return
+ * `not_active`.
+ */
+export const HOSTED_MAX_CONSUMED_DELIVERY_IDS = 16;
+
+/** Hosted-execution run mode. Omitted/`execute` is the legacy wait path. */
+export type HostedExecutionMode = "execute" | "enqueue";
+
 export type HostedExecution = {
   v: 2;
   admissionToken: string;
   sessionPublicId: string;
+  /**
+   * `execute` (default when omitted) runs the owner send and waits for the
+   * coalesce chain. `enqueue` injects into an accepting owner or returns
+   * `not_active`.
+   */
+  mode?: HostedExecutionMode;
 };
 
-export type HostedExecutionOutcome = {
-  ok: true;
-  v: 2;
-  outcome: "send";
-};
+export type HostedExecutionOutcome =
+  | {
+      ok: true;
+      v: 2;
+      outcome: "send";
+      /**
+       * Primary delivery id then accepted enqueue ids; length 1..16.
+       * Optional for old-guest compatibility; callers must normalize absent
+       * lists to `[primaryDeliveryId]`.
+       */
+      consumedDeliveryIds?: string[];
+    }
+  | { ok: true; v: 2; outcome: "enqueued" }
+  | { ok: true; v: 2; outcome: "not_active" };
 
 const DELIVERY_KEYS = new Set([
   "v",
@@ -289,7 +314,12 @@ const MANAGED_AUTOMATION_KEYS = new Set([
 const MANAGED_AUTOMATION_MAX_SERVERS = 64;
 /** More channels than the dashboard picker allows is a malformed envelope. */
 const MANAGED_AUTOMATION_MAX_SLACK_CHANNELS = 64;
-const EXECUTION_KEYS = new Set(["v", "admissionToken", "sessionPublicId"]);
+const EXECUTION_KEYS = new Set([
+  "v",
+  "admissionToken",
+  "sessionPublicId",
+  "mode",
+]);
 
 function boundedString(value: unknown, max: number): value is string {
   return typeof value === "string" && value.length > 0 && value.length <= max;
@@ -311,11 +341,11 @@ function parseManagedAutomation(
   }
   const body = value as Record<string, unknown>;
   if (
-    Object.keys(body).some((key) => !MANAGED_AUTOMATION_KEYS.has(key)) ||
+    Object.keys(body).some(key => !MANAGED_AUTOMATION_KEYS.has(key)) ||
     !boundedString(body.automationUuid, 128) ||
     !Array.isArray(body.mcpServerNames) ||
     body.mcpServerNames.length > MANAGED_AUTOMATION_MAX_SERVERS ||
-    !body.mcpServerNames.every((name) => boundedString(name, 256))
+    !body.mcpServerNames.every(name => boundedString(name, 256))
   ) {
     return undefined;
   }
@@ -324,7 +354,7 @@ function parseManagedAutomation(
       !Array.isArray(body.slackChannels) ||
       body.slackChannels.length === 0 ||
       body.slackChannels.length > MANAGED_AUTOMATION_MAX_SLACK_CHANNELS ||
-      !body.slackChannels.every((channel) => boundedString(channel, 64))
+      !body.slackChannels.every(channel => boundedString(channel, 64))
     ) {
       return undefined;
     }
@@ -348,7 +378,7 @@ export function parseHostedAdmission(
   }
   const body = value as Record<string, unknown>;
   if (
-    Object.keys(body).some((key) => !DELIVERY_KEYS.has(key)) ||
+    Object.keys(body).some(key => !DELIVERY_KEYS.has(key)) ||
     !Object.hasOwn(body, "payload") ||
     body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION ||
     !boundedString(body.channelId, 128) ||
@@ -375,7 +405,7 @@ export function parseHostedExecution(
   }
   const body = value as Record<string, unknown>;
   if (
-    Object.keys(body).some((key) => !EXECUTION_KEYS.has(key)) ||
+    Object.keys(body).some(key => !EXECUTION_KEYS.has(key)) ||
     body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION ||
     !boundedString(body.admissionToken, 128) ||
     typeof body.sessionPublicId !== "string" ||
@@ -383,9 +413,77 @@ export function parseHostedExecution(
   ) {
     return undefined;
   }
+  if (
+    body.mode !== undefined &&
+    body.mode !== "execute" &&
+    body.mode !== "enqueue"
+  ) {
+    return undefined;
+  }
   return body as HostedExecution;
 }
 
+const HOSTED_EXECUTION_OUTCOME_KEYS = new Set([
+  "ok",
+  "v",
+  "outcome",
+  "consumedDeliveryIds",
+]);
+
+function parseConsumedDeliveryIds(value: unknown): string[] | undefined {
+  if (!Array.isArray(value) || value.length === 0) {
+    return undefined;
+  }
+  if (value.length > HOSTED_MAX_CONSUMED_DELIVERY_IDS) {
+    return undefined;
+  }
+  if (!value.every(id => boundedString(id, 256))) {
+    return undefined;
+  }
+  return value as string[];
+}
+
+export function parseHostedExecutionOutcome(
+  value: unknown
+): HostedExecutionOutcome | undefined {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  const body = value as Record<string, unknown>;
+  if (
+    Object.keys(body).some(key => !HOSTED_EXECUTION_OUTCOME_KEYS.has(key)) ||
+    body.ok !== true ||
+    body.v !== HOSTED_DELIVERY_PROTOCOL_VERSION
+  ) {
+    return undefined;
+  }
+  if (body.outcome === "enqueued" || body.outcome === "not_active") {
+    if (body.consumedDeliveryIds !== undefined) {
+      return undefined;
+    }
+    return body as HostedExecutionOutcome;
+  }
+  if (body.outcome !== "send") {
+    return undefined;
+  }
+  // Old guests omit consumedDeliveryIds; accept and let callers normalize.
+  if (body.consumedDeliveryIds === undefined) {
+    return { ok: true, v: 2, outcome: "send" };
+  }
+  const consumedDeliveryIds = parseConsumedDeliveryIds(
+    body.consumedDeliveryIds
+  );
+  if (consumedDeliveryIds === undefined) {
+    return undefined;
+  }
+  return {
+    ok: true,
+    v: 2,
+    outcome: "send",
+    consumedDeliveryIds,
+  };
+}
+
 /**
  * True when the admission envelope is the reserved internal reminder fire
  * path (not an authored channel event).
@@ -481,7 +579,7 @@ function isJsonSafeValue(value: unknown, depth: number): boolean {
     return false;
   }
   if (Array.isArray(value)) {
-    return value.every((entry) => isJsonSafeValue(entry, depth + 1));
+    return value.every(entry => isJsonSafeValue(entry, depth + 1));
   }
   const proto = Object.getPrototypeOf(value);
   if (proto !== Object.prototype && proto !== null) {
@@ -543,7 +641,7 @@ export function parseHostedReminderFireDescriptorPayload(
   const body = value as Record<string, unknown>;
   if (
     Object.keys(body).some(
-      (key) => !HOSTED_REMINDER_FIRE_DESCRIPTOR_KEYS.has(key)
+      key => !HOSTED_REMINDER_FIRE_DESCRIPTOR_KEYS.has(key)
     )
   ) {
     return undefined;

package/src/internal/hosted-delivery.ts

@@ -38,6 +38,7 @@ import {
   HOSTED_EXECUTION_PATH,
   HOSTED_GUEST_RETRY_TERMINAL,
   HOSTED_GUEST_RETRY_TRANSIENT,
+  HOSTED_MAX_CONSUMED_DELIVERY_IDS,
   type HostedAdmission,
   type HostedGuestRetryDisposition,
   type HostedReminderFireDescriptorPayload,
@@ -58,6 +59,13 @@ import {
   flushHostedExecutionRecord,
   type HostedExecutionFlushSinks,
 } from "./hosted-execution-flush.js";
+import {
+  finalizeHostedExecutionLatency,
+  formatHostedExecutionLatencyServerTiming,
+  type HostedExecutionLatencySnapshot,
+  hostedExecutionNow,
+  runWithHostedExecutionLatency,
+} from "./hosted-execution-latency.js";
 import { recordHostedManagedAutomation } from "./hosted-managed-automation.js";
 import { readJsonObject } from "./http-channel.js";
 import type { LogRingEntry } from "./log-ring.js";
@@ -71,6 +79,10 @@ import {
   statusForThrownRequestError,
 } from "./request-error-status.js";
 import type { Router } from "./router.js";
+import {
+  type EngineSendOptions,
+  HostedEnqueueNotActiveError,
+} from "./session-engine.js";
 import type { SessionRunExecutionWrite } from "./session-run-log.js";
 
 type DispatchInput = {
@@ -96,6 +108,19 @@ type ExecutionReply = {
   body: Record<string, unknown>;
 };
 
+type HostedEnqueueOutcome = {
+  outcome: "enqueued" | "not_active";
+};
+
+type ActiveOwnerContext = {
+  primaryDeliveryId: string;
+  acceptedDeliveryIds: string[];
+  accepting: boolean;
+  inflightInjects: Set<Promise<void>>;
+  /** Shared result for duplicate enqueue deliveryId retries. */
+  enqueueResults: Map<string, Promise<HostedEnqueueOutcome>>;
+};
+
 /**
  * A second `send()` in one delivery is a deterministic authored bug — the
  * wire protocol carries exactly one pending send per delivery — so it must
@@ -352,7 +377,7 @@ async function runAdmission(
       captured = { message, options };
       return createDeferredChannelSession();
     },
-    waitUntil: (promise) => {
+    waitUntil: promise => {
       background.push(promise);
     },
   };
@@ -365,6 +390,7 @@ async function runAdmission(
       payload: input.delivery.payload,
       deliveryId: input.delivery.deliveryId,
       args,
+      mailboxContinuationKey: input.delivery.mailboxContinuationKey,
     });
   } catch (error) {
     const mapped = mappedAdmissionFailure(error);
@@ -438,7 +464,8 @@ async function runAdmission(
 function withServerTiming(
   response: Response,
   durationMs: number,
-  guestNetwork?: GuestNetworkWaitStats
+  guestNetwork?: GuestNetworkWaitStats,
+  latency?: HostedExecutionLatencySnapshot
 ): Response {
   const parts = [
     `agent_sdk;desc="hosted";dur=${Math.max(0, durationMs).toFixed(1)}`,
@@ -446,6 +473,9 @@ function withServerTiming(
   if (guestNetwork !== undefined) {
     parts.push(formatGuestNetworkServerTiming(guestNetwork));
   }
+  if (latency !== undefined) {
+    parts.push(...formatHostedExecutionLatencyServerTiming(latency));
+  }
   const headers = new Headers(response.headers);
   headers.set("Server-Timing", parts.join(", "));
   return new Response(response.body, {
@@ -585,11 +615,14 @@ export function registerHostedDeliveryRoute(input: {
     string,
     {
       send: PendingSend;
+      channelKind: string;
       expiresAt: number;
+      deliveryId: string;
       sessionPublicId?: string;
       execution?: Promise<ExecutionReply>;
     }
   >();
+  const activeOwners = new Map<string, ActiveOwnerContext>();
   const pendingTtlMs = 10 * 60_000;
   const waitForNetwork =
     input.waitForGuestNetwork ?? (() => waitForGuestNetworkReady());
@@ -650,7 +683,7 @@ export function registerHostedDeliveryRoute(input: {
 
   // Hosted callers reach this only through AnyRun's signed pod-port URL.
   // The marker is a second, route-specific fence distinct from channel auth.
-  const auth: AuthPolicy = (request) => {
+  const auth: AuthPolicy = request => {
     if (request.headers.get(HOSTED_DELIVERY_HEADER) !== "1") {
       return null;
     }
@@ -664,7 +697,7 @@ export function registerHostedDeliveryRoute(input: {
     method: "POST",
     pattern: `${input.base}${HOSTED_ADMISSION_PATH}`,
     auth: [auth],
-    handler: async (request) =>
+    handler: async request =>
       afterHostedWork(input.flushOtel, async () => {
         const startedAt = performance.now();
         let guestNetwork: GuestNetworkWaitStats | undefined;
@@ -711,7 +744,7 @@ export function registerHostedDeliveryRoute(input: {
           return finish(await dispatchHostedReminderAdmission(input, delivery));
         }
         const channel = input.channels.find(
-          (candidate) => candidate.id === delivery.channelId
+          candidate => candidate.id === delivery.channelId
         );
         if (channel === undefined) {
           return finish(
@@ -739,7 +772,9 @@ export function registerHostedDeliveryRoute(input: {
         const admissionToken = randomBytes(24).toString("hex");
         pending.set(admissionToken, {
           send: admitted.pendingSend,
+          channelKind: delivery.channelKind,
           expiresAt: Date.now() + pendingTtlMs,
+          deliveryId: delivery.deliveryId,
         });
         return finish(
           Response.json({
@@ -755,15 +790,17 @@ export function registerHostedDeliveryRoute(input: {
     method: "POST",
     pattern: `${input.base}${HOSTED_EXECUTION_PATH}`,
     auth: [auth],
-    handler: async (request) =>
+    handler: async request =>
       afterHostedWork(input.flushOtel, async () => {
         const startedAt = performance.now();
         let guestNetwork: GuestNetworkWaitStats | undefined;
+        let latencySnapshot: HostedExecutionLatencySnapshot | undefined;
         const finish = (response: Response) =>
           withServerTiming(
             response,
             performance.now() - startedAt,
-            guestNetwork
+            guestNetwork,
+            latencySnapshot
           );
         const unconsumed = finishBoundSecrets();
         if (unconsumed !== undefined) {
@@ -808,6 +845,24 @@ export function registerHostedDeliveryRoute(input: {
           return finish(network.response);
         }
         admitted.sessionPublicId = execution.sessionPublicId;
+
+        if (execution.mode === "enqueue") {
+          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,
+            })
+          );
+        }
+
         admitted.execution ??= (async (): Promise<ExecutionReply> => {
           const startedAt = performance.now();
           const executionId = hostedExecutionDiagId(execution.admissionToken);
@@ -868,83 +923,147 @@ export function registerHostedDeliveryRoute(input: {
             turnStatus: HOSTED_EXECUTION_DIAG_RUNNING_STATUS,
           });
           let sessionId = "";
-          try {
-            const args = input.buildHandlerArgs(
-              admitted.send.channelId,
-              execution.sessionPublicId
-            );
-            const session = await args.send(admitted.send.message, {
-              ...admitted.send.options,
-              mailboxContinuation: {
-                key: admitted.send.mailboxContinuationKey,
-              },
-            });
-            sessionId = session.id;
-            const outcome = await session.waitForCompletion();
-            // Failed turns drain too: their record/continuation updates must
-            // survive the park just like a finished turn's.
-            await input.drainSessionDurability?.(session.id);
-            // 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,
-            });
-            if (hostedFailure !== undefined) {
-              return {
-                status: 503,
-                body: {
-                  ok: false,
-                  error: hostedFailure.error,
-                  retry: hostedFailure.retry,
-                  classification: hostedFailureClassification(
-                    hostedFailure.error
-                  ),
+          const owner: ActiveOwnerContext = {
+            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: number | undefined;
+              let drainAt: number | undefined;
+              try {
+                const args = input.buildHandlerArgs(
+                  admitted.send.channelId,
+                  execution.sessionPublicId
+                );
+                const session = await args.send(admitted.send.message, {
+                  ...admitted.send.options,
+                  mailboxContinuation: {
+                    key: admitted.send.mailboxContinuationKey,
+                  },
+                });
+                sessionId = session.id;
+                const outcome = await 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]);
+                }
+                // 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)}`
+                  );
+                }
+                // 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,
+                });
+                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,
+                        },
+                      }
+                    : {
+                        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 reply;
+              } catch (error) {
+                owner.accepting = false;
+                if (owner.inflightInjects.size > 0) {
+                  await Promise.allSettled([...owner.inflightInjects]);
+                }
+                evictHostedSdkSessions(
+                  input.evictSdkSession,
+                  sessionId,
+                  execution.sessionPublicId
+                );
+                await writeDiag({
+                  sessionId: "",
+                  turnStatus: "error",
+                  message:
+                    error instanceof Error ? error.message : String(error),
+                  abortReason: "execute_throw",
+                  failureCode: "internal_error",
+                  error,
+                });
+                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;
+              } finally {
+                if (activeOwners.get(execution.sessionPublicId) === owner) {
+                  activeOwners.delete(execution.sessionPublicId);
+                }
+              }
             }
-            return {
-              status: 200,
-              body: {
-                ok: true,
-                v: HOSTED_DELIVERY_PROTOCOL_VERSION,
-                outcome: "send",
-              },
-            };
-          } catch (error) {
-            evictHostedSdkSessions(
-              input.evictSdkSession,
-              sessionId,
-              execution.sessionPublicId
-            );
-            await writeDiag({
-              sessionId: "",
-              turnStatus: "error",
-              message: error instanceof Error ? error.message : String(error),
-              abortReason: "execute_throw",
-              failureCode: "internal_error",
-              error,
-            });
-            throw error;
-          }
+          );
         })();
         const reply = await admitted.execution;
         return finish(Response.json(reply.body, { status: reply.status }));
@@ -952,6 +1071,92 @@ export function registerHostedDeliveryRoute(input: {
   });
 }
 
+async function enqueueIntoActiveOwner(input: {
+  activeOwners: Map<string, ActiveOwnerContext>;
+  sessionPublicId: string;
+  deliveryId: string;
+  send: PendingSend;
+  buildHandlerArgs: (
+    channelId: string,
+    sessionPublicId?: string
+  ) => ChannelHandlerArgs;
+}): Promise<HostedEnqueueOutcome> {
+  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 };
+    }
+    return { outcome: "not_active" };
+  }
+
+  let resolveResult!: (value: HostedEnqueueOutcome) => void;
+  const resultPromise = new Promise<HostedEnqueueOutcome>(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" as const };
+    resolveResult(outcome);
+    return outcome;
+  }
+
+  // Reserve before send so concurrent enqueues cannot oversubscribe.
+  owner.acceptedDeliveryIds.push(input.deliveryId);
+
+  const inject = (async (): Promise<void> => {
+    try {
+      const args = input.buildHandlerArgs(
+        input.send.channelId,
+        input.sessionPublicId
+      );
+      const enqueueOptions = {
+        ...input.send.options,
+        mailboxContinuation: {
+          key: input.send.mailboxContinuationKey,
+        },
+        hostedEnqueueOnly: true,
+      } as SendMessageOptions & EngineSendOptions;
+      const session = await 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);
+      }
+      resolveResult({ outcome: "not_active" });
+      if (!(error instanceof HostedEnqueueNotActiveError)) {
+        console.warn(
+          `[agent-sdk] hosted enqueue inject failed deliveryId=${input.deliveryId}: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        );
+      }
+    }
+  })();
+
+  owner.inflightInjects.add(inject);
+  try {
+    await inject;
+  } finally {
+    owner.inflightInjects.delete(inject);
+  }
+  return await resultPromise;
+}
+
 function evictHostedSdkSessions(
   evict: ((sessionId: string) => void) | undefined,
   ...ids: Array<string | undefined>