@agent-native/core 0.78.4 → 0.78.7

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
@@ -3170,6 +3180,30 @@ export function createProductionAgentHandler(options) {
             ? requestEffort
             : options.reasoningEffort);
         options.onEngineResolved?.(engine, model);
+        // DIAGNOSTIC-ONLY: localize where the worker stalls AFTER model_done. These
+        // land in `worker_stage` (foreground-independent), so even though the
+        // foreground overwrites `diag_stage` on inline recovery, the worker's last
+        // reached point survives. If the last worker_stage is `model_done`, writes
+        // 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.
@@ -3209,10 +3243,17 @@ export function createProductionAgentHandler(options) {
         let systemPromptError = null;
         const systemPromptThunk = () => (async () => {
             const sysPromptStart = Date.now();
+            // Brackets the system-prompt build (which runs the template's
+            // extraContext / data-dictionary). If worker_stage stalls at
+            // `systemprompt_enter` with no `systemprompt_done`, the build itself is
+            // the stall point.
+            workerStep("systemprompt_enter");
             try {
-                return typeof options.systemPrompt === "function"
+                const built = typeof options.systemPrompt === "function"
                     ? await options.systemPrompt(event)
                     : options.systemPrompt;
+                workerStep("systemprompt_done");
+                return built;
             }
             catch (error) {
                 systemPromptError = error;
@@ -3923,6 +3964,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