@agent-native/core 0.84.14 → 0.84.16

package/dist/server/agent-chat-plugin.js

@@ -7,7 +7,7 @@ import { updateTaskStatusMessage } from "../a2a/task-store.js";
 import { ACTION_CHAT_UI_DATA_WIDGET_RENDERER } from "../action-ui.js";
 import { canUpdateAgentAppModelDefaultSettings, normalizeAgentAppModelDefaultAppId, readAgentAppModelDefaultSettings, resetAgentAppModelDefaultSettings, writeAgentAppModelDefaultSettings, } from "../agent/app-model-defaults.js";
 import { DEFAULT_ANTHROPIC_MODEL } from "../agent/default-model.js";
-import { AGENT_CHAT_PROCESS_RUN_PATH, extractProcessRunId, isInBackgroundFunctionRuntime, prepareProcessRunRequest, } from "../agent/durable-background.js";
+import { AGENT_CHAT_BACKGROUND_RUN_FIELD, AGENT_CHAT_PROCESS_RUN_PATH, backgroundRunMarkerExpectsBackgroundRuntime, isInBackgroundFunctionRuntime, prepareProcessRunRequest, } from "../agent/durable-background.js";
 import { resolveEngine, createAnthropicEngine, getStoredModelForEngine, normalizeModelForEngine, getAgentEngineEntry, isAgentEnginePackageInstalled, isStoredEngineUsableForRequest, listAgentEngines, registerBuiltinEngines, } from "../agent/engine/index.js";
 import { createProductionAgentHandler, actionsToEngineTools, getActiveRunForThreadAsync, abortRun, subscribeToRun, } from "../agent/production-agent.js";
 import { runAgentLoopDirectWithSoftTimeout } from "../agent/run-loop-with-resume.js";
@@ -6233,18 +6233,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setResponseStatus(event, 405);
                     return { error: "Method not allowed" };
                 }
-                // DIAGNOSTIC: load the run-store diagnostic recorder. Each stage we
-                // reach is written onto the run row (diag_stage) so a silent failure
-                // INSIDE the Netlify background function — whose logs we cannot read —
-                // is still diagnosable from the client via /runs/active. Best-effort:
-                // the import + every record call is wrapped so diagnostics can never
-                // break the worker path.
-                const diag = await import("../agent/run-store.js")
-                    .then((m) => ({
-                    record: m.recordRunDiagnostic,
-                    stages: m.RUN_DIAG_STAGE,
-                }))
-                    .catch(() => null);
                 // Consume the body ONCE (h3 v2's web Request stream is single-use).
                 let processBody;
                 try {
@@ -6254,17 +6242,6 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setResponseStatus(event, 400);
                     return { error: "Invalid request body" };
                 }
-                // Record "the route handler was entered" against the run BEFORE auth
-                // runs. This is the proof the bg-fn invocation actually reached Nitro
-                // (vs. dying at the function entry / never being invoked). The runId
-                // is parsed without authenticating so we can attach it even on a
-                // subsequent auth failure.
-                const diagRunId = extractProcessRunId(processBody);
-                if (diag && diagRunId) {
-                    await diag
-                        .record(diagRunId, diag.stages.routeEntered)
-                        .catch(() => { });
-                }
                 // Validate + HMAC-authenticate the self-dispatch and prepare the
                 // background-worker body. Pure decision (unit-tested in
                 // durable-background.spec.ts); the route only wires it to h3.
@@ -6276,6 +6253,12 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     // bypassing session auth) inside the unreadable bg function would
                     // leave the run to time out with NO clue. The detail carries the
                     // status + whether A2A_SECRET is even present in this isolate.
+                    const diag = await import("../agent/run-store.js")
+                        .then((m) => ({
+                        record: m.recordRunDiagnostic,
+                        stages: m.RUN_DIAG_STAGE,
+                    }))
+                        .catch(() => null);
                     if (diag && prepared.runId) {
                         const a2aPresent = Boolean(process.env.A2A_SECRET && process.env.A2A_SECRET.length > 0);
                         await diag
@@ -6285,24 +6268,47 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setResponseStatus(event, prepared.status);
                     return { error: prepared.error };
                 }
-                // DIAGNOSTIC: auth + body validation passed. Reaching here proves the
-                // request was authenticated and we are about to invoke the worker.
-                if (diag) {
-                    await diag
-                        .record(prepared.runId, diag.stages.authPassed)
-                        .catch(() => { });
+                const preparedMarker = prepared.body[AGENT_CHAT_BACKGROUND_RUN_FIELD];
+                const expectsBackgroundRuntime = backgroundRunMarkerExpectsBackgroundRuntime(preparedMarker);
+                const runtimeGlobals = globalThis;
+                const hadExpectedRuntimeMarker = Object.prototype.hasOwnProperty.call(runtimeGlobals, "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__");
+                const previousExpectedRuntimeMarker = runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__;
+                if (expectsBackgroundRuntime) {
+                    runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ = true;
                 }
-                // Stash the verified+augmented body for the handler — the body stream
-                // is already consumed, so the handler reads this instead.
-                event.context = event.context ?? {};
-                event.context.__agentChatBackgroundBody = prepared.body;
-                // Durable owner context: this self-dispatch is cookieless (HMAC-only).
-                // Resolve the owner from the persisted run row, never the request body,
-                // then invoke the normal handler. The shared agent-run context helper
-                // expands that owner into the same user/org AsyncLocalStorage context the
-                // foreground request uses, so credential and data scoping stay aligned.
-                await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
                 try {
+                    // DIAGNOSTIC: load the run-store diagnostic recorder only after the
+                    // authenticated marker has been mirrored into globalThis. run-store
+                    // can initialize the DB pool; the pool must see the same background
+                    // proof as the agent timeout logic before that happens.
+                    const diag = await import("../agent/run-store.js")
+                        .then((m) => ({
+                        record: m.recordRunDiagnostic,
+                        stages: m.RUN_DIAG_STAGE,
+                    }))
+                        .catch(() => null);
+                    // Record "the route handler was entered" against the run after auth
+                    // succeeds. This is the proof the bg-fn invocation actually reached
+                    // Nitro (vs. dying at the function entry / never being invoked).
+                    if (diag) {
+                        await diag
+                            .record(prepared.runId, diag.stages.routeEntered)
+                            .catch(() => { });
+                        await diag
+                            .record(prepared.runId, diag.stages.authPassed)
+                            .catch(() => { });
+                    }
+                    // Stash the verified+augmented body for the handler — the body stream
+                    // is already consumed, so the handler reads this instead.
+                    event.context = event.context ?? {};
+                    event.context.__agentChatBackgroundBody = prepared.body;
+                    // Durable owner context: this self-dispatch is cookieless (HMAC-only).
+                    // Resolve the owner from the persisted run row, never the request
+                    // body, then invoke the normal handler. The shared agent-run context
+                    // helper expands that owner into the same user/org AsyncLocalStorage
+                    // context the foreground request uses, so credential and data scoping
+                    // stay aligned.
+                    await seedBackgroundAgentRunOwnerContext(event, prepared.runId);
                     return await invokeAgentChatHandler(event);
                 }
                 catch (err) {
@@ -6323,6 +6329,17 @@ Non-code requests are still fine on this surface: read data, navigate the UI, su
                     setResponseStatus(event, 500);
                     return { error: "process-run failed" };
                 }
+                finally {
+                    if (expectsBackgroundRuntime) {
+                        if (hadExpectedRuntimeMarker) {
+                            runtimeGlobals.__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__ =
+                                previousExpectedRuntimeMarker;
+                        }
+                        else {
+                            Reflect.deleteProperty(runtimeGlobals, "__AGENT_NATIVE_BACKGROUND_RUNTIME_EXPECTED__");
+                        }
+                    }
+                }
             }));
             // Mount the main chat handler — delegates to dev or prod handler based on current mode.
             // This is mounted last because h3's use() is prefix-based, meaning /_agent-native/agent-chat