@agent-native/core 0.84.4 → 0.84.6

package/dist/agent/production-agent.js

@@ -3046,6 +3046,34 @@ export function shouldChainBackgroundContinuation(opts) {
         endsAtInternalContinuationBoundary(opts.run) &&
         opts.continuationCount < MAX_BACKGROUND_RUN_CONTINUATIONS);
 }
+export async function claimBackgroundWorkerRunEarly(opts) {
+    const record = opts.deps?.recordRunDiagnostic ?? recordRunDiagnostic;
+    const insert = opts.deps?.insertRun ?? insertRun;
+    const claim = opts.deps?.claimBackgroundRun ?? claimBackgroundRun;
+    const heartbeat = opts.deps?.updateRunHeartbeat ?? updateRunHeartbeat;
+    const threadId = typeof opts.threadId === "string" && opts.threadId.trim()
+        ? opts.threadId.trim()
+        : opts.runId;
+    const turnId = typeof opts.markerTurnId === "string" && opts.markerTurnId.trim()
+        ? opts.markerTurnId.trim()
+        : typeof opts.requestTurnId === "string" && opts.requestTurnId.trim()
+            ? opts.requestTurnId.trim()
+            : opts.runId;
+    await record(opts.runId, RUN_DIAG_STAGE.workerEntered, `runsInBackgroundFunction=${opts.runsInBackgroundFunction} continuationCount=${opts.continuationCount}`).catch(() => { });
+    if (opts.continuationCount > 0) {
+        await insert(opts.runId, threadId, turnId, {
+            dispatchMode: "background",
+        }).catch(() => { });
+    }
+    const won = await claim(opts.runId);
+    if (!won) {
+        await record(opts.runId, RUN_DIAG_STAGE.workerClaimLost).catch(() => { });
+        return { claimed: false, skipped: "already-claimed" };
+    }
+    await record(opts.runId, RUN_DIAG_STAGE.workerClaimed).catch(() => { });
+    await heartbeat(opts.runId).catch(() => { });
+    return { claimed: true };
+}
 function progressStepFromAgentChatEvent(event) {
     switch (event.type) {
         case "activity":
@@ -3164,6 +3192,23 @@ export function createProductionAgentHandler(options) {
             Number.isFinite(backgroundRunMarker.continuationCount)
             ? Math.max(0, Math.floor(backgroundRunMarker.continuationCount))
             : 0;
+        let backgroundRunClaimedEarly = false;
+        if (isBackgroundWorker && bgRunId) {
+            const earlyClaim = await claimBackgroundWorkerRunEarly({
+                runId: bgRunId,
+                threadId,
+                markerTurnId: typeof backgroundRunMarker?.turnId === "string"
+                    ? backgroundRunMarker.turnId
+                    : null,
+                requestTurnId,
+                continuationCount: backgroundContinuationCount,
+                runsInBackgroundFunction,
+            });
+            if (!earlyClaim.claimed) {
+                return { ok: true, skipped: earlyClaim.skipped };
+            }
+            backgroundRunClaimedEarly = true;
+        }
         // The foreground POST decides whether to dispatch into a background
         // function. The background worker itself never re-dispatches.
         const dispatchToBackground = !isBackgroundWorker &&
@@ -4061,40 +4106,28 @@ export function createProductionAgentHandler(options) {
                 }
             }
             : undefined;
-        // Background worker: claim the pre-inserted run idempotently before
-        // executing. A duplicate Netlify delivery loses the claim and no-ops here,
-        // so the run can never be double-executed. Bump the heartbeat immediately
-        // on entry so a slow cold-start doesn't leave the row looking stale to the
-        // reaper before startRun's 1.5s heartbeat timer takes over.
+        // Background worker: the run was claimed immediately after the authenticated
+        // `_process-run` body was parsed, before owner/model/prompt/tool setup. That
+        // early claim is what lets the foreground subscribe to the real background
+        // worker instead of racing slow setup and falling back to the 40s inline
+        // path. This late block is a defensive fallback for older/custom callers
+        // that somehow reach here without the early claim.
         if (isBackgroundWorker) {
-            // DIAGNOSTIC: the re-entered handler recognized itself as the background
-            // worker. Record the runtime regime too — `isInBackgroundFunctionRuntime()`
-            // reads a globalThis marker set by the bg-fn entry, which may NOT be set in
-            // this isolate; recording the ACTUAL resolved value reveals whether the
-            // worker is on the 13-min `-background` budget or the 40s clamp. This is
-            // the proof the worker reached its own code (vs. dying at auth before it).
-            await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerEntered, `runsInBackgroundFunction=${runsInBackgroundFunction} continuationCount=${backgroundContinuationCount}`).catch(() => { });
-            // A chained continuation chunk's runId was minted by the prior chunk and
-            // never inserted, so insert its background row now (idempotently — a
-            // duplicate Netlify delivery that already inserted it just PK-collides and
-            // the claim below dedups). The first chunk's row was inserted by the
-            // foreground, so skip the insert there.
-            if (isChainedBackgroundContinuation) {
-                await insertRun(runId, effectiveThreadId, effectiveTurnId, {
-                    dispatchMode: "background",
-                }).catch(() => { });
-            }
-            const won = await claimBackgroundRun(runId);
-            if (!won) {
-                // Already claimed by an earlier delivery — return a benign ack so
-                // Netlify doesn't retry a successful handoff.
-                await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerClaimLost).catch(() => { });
-                return { ok: true, skipped: "already-claimed" };
+            if (!backgroundRunClaimedEarly) {
+                await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerEntered, `runsInBackgroundFunction=${runsInBackgroundFunction} continuationCount=${backgroundContinuationCount}`).catch(() => { });
+                if (isChainedBackgroundContinuation) {
+                    await insertRun(runId, effectiveThreadId, effectiveTurnId, {
+                        dispatchMode: "background",
+                    }).catch(() => { });
+                }
+                const won = await claimBackgroundRun(runId);
+                if (!won) {
+                    await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerClaimLost).catch(() => { });
+                    return { ok: true, skipped: "already-claimed" };
+                }
+                await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerClaimed).catch(() => { });
+                await updateRunHeartbeat(runId).catch(() => { });
             }
-            // DIAGNOSTIC: this worker won the claim and now OWNS the run. If a run
-            // ever stalls at this stage it means the loop below failed to start.
-            await recordRunDiagnostic(runId, RUN_DIAG_STAGE.workerClaimed).catch(() => { });
-            await updateRunHeartbeat(runId).catch(() => { });
         }
         // DIAGNOSTIC-ONLY: build the pre-startRun setup-timing breakdown now (so the
         // marks reflect the work done BEFORE the loop), but EMIT it from inside