@agent-native/core 0.78.5 → 0.78.8

package/dist/agent/production-agent.js

@@ -13,7 +13,7 @@ import { completeRun as completeProgressRun, startRun as startProgressRun, updat
 import { getFrontmatterValue, parseFrontmatter, } from "../resources/metadata.js";
 import { isDeployCredentialFallbackAllowed, readDeployCredentialEnv, } from "../server/credential-provider.js";
 import { readBody } from "../server/h3-helpers.js";
-import { getRequestRunContext, ensureRequestRunContext, getRequestOrgId, getRequestUserEmail, } from "../server/request-context.js";
+import { getRequestRunContext, ensureRequestRunContext, getRequestContext, getRequestOrgId, getRequestUserEmail, runWithRequestContext, } from "../server/request-context.js";
 import { fireInternalDispatch } from "../server/self-dispatch.js";
 import { isReasoningEffort, normalizeReasoningEffortForModel, } from "../shared/reasoning-effort.js";
 import { applyContextDirectives } from "./context-xray/apply-directives.js";
@@ -2537,13 +2537,12 @@ export async function runAgentLoop(opts) {
             let mcpApp;
             try {
                 const timeoutSignal = AbortSignal.timeout(toolTimeoutMs);
-                // Keep a reference to the action promise so we can attach a zombie-
-                // detection continuation AFTER Promise.race abandons it on run abort.
-                // The promise itself is not awaited here — Promise.race owns the await.
-                const actionPromise = Promise.resolve(actionEntry.run(toolCall.input, {
+                const actionUserEmail = opts.ownerEmail ?? getRequestUserEmail();
+                const actionOrgId = opts.orgId ?? getRequestOrgId() ?? null;
+                const actionContext = {
                     send,
-                    userEmail: getRequestUserEmail(),
-                    orgId: getRequestOrgId() ?? null,
+                    userEmail: actionUserEmail ?? undefined,
+                    orgId: actionOrgId,
                     caller: "tool",
                     attachments: opts.attachments,
                     signal,
@@ -2552,7 +2551,18 @@ export async function runAgentLoop(opts) {
                     actionName: toolCall.name,
                     ...(opts.threadId ? { threadId: opts.threadId } : {}),
                     ...(opts.turnId ? { turnId: opts.turnId } : {}),
-                }));
+                };
+                const requestContext = getRequestContext();
+                const invokeAction = () => actionEntry.run(toolCall.input, actionContext);
+                // Keep a reference to the action promise so we can attach a zombie-
+                // detection continuation AFTER Promise.race abandons it on run abort.
+                // The promise itself is not awaited here — Promise.race owns the await.
+                const actionPromise = Promise.resolve(runWithRequestContext({
+                    ...(requestContext ?? {}),
+                    ...(actionUserEmail ? { userEmail: actionUserEmail } : {}),
+                    ...(actionOrgId ? { orgId: actionOrgId } : {}),
+                    ...(requestContext?.run ? { run: requestContext.run } : {}),
+                }, invokeAction));
                 // When the run is aborted (soft-timeout / user cancel) while this tool
                 // call is in flight, Promise.race below will throw "Run aborted" and the
                 // action's promise becomes a zombie — it keeps running but its result is
@@ -2975,6 +2985,23 @@ export function createProductionAgentHandler(options) {
             if (bgRunId)
                 void recordRunDiagnostic(bgRunId, RUN_DIAG_STAGE.workerSetupStep, `${s}=${Date.now() - setupT0}ms`).catch(() => { });
         };
+        // DIAGNOSTIC-ONLY: AWAITED worker mark. Fire-and-forget workerStep marks
+        // after `post_model_ok` stopped landing even though writes still work
+        // there — so the worker's MAIN FLOW stalls between post_model and pre_claim
+        // (not a write hang). Awaited marks block until they land (or withDbTimeout-
+        // reject), so `worker_stage` reliably advances to the last phase the main
+        // flow actually reached — pinpointing the stall. Bg worker only.
+        const awaitedWorkerMark = async (s) => {
+            if (!isBackgroundWorker || !bgRunId)
+                return;
+            try {
+                await recordRunDiagnostic(bgRunId, RUN_DIAG_STAGE.workerSetupStep, `${s}=${Date.now() - setupT0}ms`);
+            }
+            catch {
+                // bounded by withDbTimeout; ignore — the absence of the next mark is
+                // itself the signal.
+            }
+        };
         // Whether this worker is REALLY executing inside a 15-min Netlify
         // `-background` function (proven by the runtime function name), not merely a
         // `_process-run` re-entry that may have landed on the ~60s synchronous
@@ -3177,6 +3204,23 @@ export function createProductionAgentHandler(options) {
         // hang right after model resolution (DB connection); if it's
         // `engine_resolved`/`systemprompt_enter`, the stall is in the named step.
         workerStep("engine_resolved");
+        // DIAGNOSTIC-ONLY: AWAITED probe (bg worker only). worker_stage stalls at
+        // `model_done` even though the code right after is trivial sync — this
+        // distinguishes the two causes: if `post_model_awaited` lands, DB writes
+        // still work after model_done and the stall is later in the main flow; if it
+        // never lands (stays `model_done`), the bg-fn DB connection itself is hung
+        // right after model resolution. `recordRunDiagnostic` is `withDbTimeout`-
+        // bounded, so a hung write rejects (caught) rather than blocking forever.
+        if (isBackgroundWorker && bgRunId) {
+            const probeStart = Date.now();
+            try {
+                await recordRunDiagnostic(bgRunId, RUN_DIAG_STAGE.workerSetupStep, "post_model_awaited");
+                workerStep(`post_model_ok=${Date.now() - probeStart}ms`);
+            }
+            catch (e) {
+                workerStep(`post_model_threw=${Date.now() - probeStart}ms:${String(e?.message ?? e).slice(0, 80)}`);
+            }
+        }
         // One-line per-turn resolution log so it's obvious in dev which engine
         // is actually handling the request. `requestEngine` is what the client
         // sent from the model picker; `engine.name` is what resolveEngine picked.
@@ -3205,6 +3249,7 @@ export function createProductionAgentHandler(options) {
         // reached db_request_ctx but not env_config hung in attachment upload or
         // engine/model resolution.
         workerStep("env_config");
+        await awaitedWorkerMark("aw_env");
         // Run all independent pre-send steps in parallel. Each of these hits
         // the DB or invokes an action; running them sequentially was the
         // single biggest contributor to pre-LLM latency.
@@ -3461,6 +3506,7 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: all parallel context gathering (system prompt, screen,
         // files, loop settings, enriched message) resolved.
         workerStep("context_all");
+        await awaitedWorkerMark("aw_presend");
         if (systemPromptError) {
             setResponseHeader(event, "Content-Type", "text/event-stream");
             setResponseHeader(event, "Cache-Control", "no-cache");
@@ -3482,6 +3528,7 @@ export function createProductionAgentHandler(options) {
         setupMark("actions");
         // DIAGNOSTIC-ONLY: action/tool resolution + engine-tool filtering finished.
         workerStep("action_tool_setup");
+        await awaitedWorkerMark("aw_actions");
         const requestSystemPrompt = requestMode === "plan"
             ? `${systemPrompt}\n\n${PLAN_MODE_SYSTEM_PROMPT}`
             : systemPrompt;
@@ -3581,6 +3628,7 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: owner/thread resolution + runId/effectiveThreadId +
         // chained-continuation thread fetch finished.
         workerStep("owner_thread");
+        await awaitedWorkerMark("aw_owner");
         // Persist the user's turn exactly once. The foreground POST does this
         // before dispatching; the background worker must NOT repeat it (it re-enters
         // with the same body, which would double-persist the user message).
@@ -3937,6 +3985,21 @@ export function createProductionAgentHandler(options) {
         // DIAGNOSTIC-ONLY: last stage before startRun fires. A worker that reaches
         // prestart but never workerStarted is hanging inside startRun itself.
         workerStep("prestart");
+        // DIAGNOSTIC-ONLY: AWAITED probe right before startRun (bg worker only). If
+        // worker_stage reaches `pre_claim_ok` but the run never flips to
+        // `worker_started`, the stall is inside startRun's claim itself; if it never
+        // reaches `pre_claim_*`, the stall is somewhere in the setup between
+        // post_model and here.
+        if (isBackgroundWorker && bgRunId) {
+            const claimProbeStart = Date.now();
+            try {
+                await recordRunDiagnostic(bgRunId, RUN_DIAG_STAGE.workerSetupStep, "pre_claim");
+                workerStep(`pre_claim_ok=${Date.now() - claimProbeStart}ms`);
+            }
+            catch (e) {
+                workerStep(`pre_claim_threw=${Date.now() - claimProbeStart}ms:${String(e?.message ?? e).slice(0, 80)}`);
+            }
+        }
         // DIAGNOSTIC-ONLY: peak-ish RSS (MB) + assembled system-prompt size (KB) at
         // prestart. The analytics bg worker dies right after model_done; if the
         // FOREGROUND (identical build, writes land) is already near the ~1024MB