@agent-native/core 0.37.3 → 0.39.0

package/dist/agent/production-agent.js

@@ -22,6 +22,7 @@ import { isAgentActionStopError } from "../action.js";
 import { preUploadImageAttachments } from "../file-upload/pre-upload-attachments.js";
 import { extensionIdFromPathname } from "../extensions/path.js";
 import { applyContextDirectives } from "./context-xray/apply-directives.js";
+import { completeRun as completeProgressRun, startRun as startProgressRun, updateRunProgress, } from "../progress/registry.js";
 import { loadContextDirectives } from "./context-xray/directives-store.js";
 import { buildManifest, writeContextManifest, } from "./context-xray/manifest.js";
 import { computeProtectedSegmentIds } from "./context-xray/segments.js";
@@ -1409,7 +1410,12 @@ export async function runAgentLoop(opts) {
             try {
                 const timeoutSignal = AbortSignal.timeout(TOOL_TIMEOUT_MS);
                 const raw = await Promise.race([
-                    actionEntry.run(toolCall.input, { send }),
+                    actionEntry.run(toolCall.input, {
+                        send,
+                        userEmail: getRequestUserEmail(),
+                        orgId: getRequestOrgId() ?? null,
+                        caller: "tool",
+                    }),
                     new Promise((_, reject) => {
                         timeoutSignal.addEventListener("abort", () => reject(new Error("Tool call timed out after 60 seconds")));
                     }),
@@ -1579,6 +1585,68 @@ export async function runAgentLoop(opts) {
         send({ type: "done" });
     return usage;
 }
+function backgroundChatProgressRunId(turnId) {
+    const normalized = turnId
+        .trim()
+        .replace(/[^a-zA-Z0-9._:-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 160);
+    return `agent-chat-${normalized || "turn"}`;
+}
+function isRecoverableContinuationError(event) {
+    const code = String(event.errorCode ?? "").toLowerCase();
+    const message = event.error.toLowerCase();
+    if (code === "builder_gateway_error")
+        return false;
+    return (event.recoverable === true ||
+        code === "builder_gateway_timeout" ||
+        code === "stale_run" ||
+        code === "timeout" ||
+        code === "timeout_error" ||
+        code === "http_408" ||
+        code === "http_429" ||
+        code === "http_529" ||
+        code === "run_timeout" ||
+        message.includes("timeout") ||
+        message.includes("temporarily unavailable"));
+}
+function endsAtInternalContinuationBoundary(run) {
+    const last = run.events.at(-1)?.event;
+    if (!last)
+        return false;
+    if (last.type === "auto_continue" || last.type === "loop_limit") {
+        return true;
+    }
+    return last.type === "error" && isRecoverableContinuationError(last);
+}
+function progressStepFromAgentChatEvent(event) {
+    switch (event.type) {
+        case "activity":
+            return event.label;
+        case "tool_start":
+            return `Using ${event.tool}.`;
+        case "tool_done":
+            return `Finished ${event.tool}.`;
+        case "agent_call":
+            return event.status === "start"
+                ? `Calling ${event.agent}.`
+                : event.status === "done"
+                    ? `Finished ${event.agent}.`
+                    : `${event.agent} failed.`;
+        case "agent_task":
+            return event.status === "running"
+                ? "Started background task."
+                : event.status === "completed"
+                    ? "Background task completed."
+                    : "Background task failed.";
+        case "agent_task_update":
+            return event.currentStep || event.preview || "Background task updated.";
+        case "text":
+            return "Agent is responding.";
+        default:
+            return null;
+    }
+}
 export function createProductionAgentHandler(options) {
     // Undefined = let each engine pick its own defaultModel at request time.
     const configuredModel = options.model;
@@ -1612,7 +1680,7 @@ export function createProductionAgentHandler(options) {
             setResponseStatus(event, 400);
             return { error: "Invalid request body" };
         }
-        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, internalContinuation, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, } = body;
+        const { message, history = [], structuredHistory, references = [], threadId, attachments, displayMessage, internalContinuation, turnId: requestTurnId, model: requestModel, engine: requestEngine, effort: requestEffort, browserTabId, scope, trackInRunsTray, } = body;
         const requestBrowserTabId = normalizeBrowserTabId(browserTabId);
         const requestChatScope = normalizeChatScope(scope);
         const requestRunCtx = ensureRequestRunContext();
@@ -1782,7 +1850,11 @@ export function createProductionAgentHandler(options) {
             try {
                 const viewScreenAction = resolvedActions["view-screen"];
                 if (viewScreenAction) {
-                    const result = await viewScreenAction.run({});
+                    const result = await viewScreenAction.run({}, {
+                        userEmail: getRequestUserEmail(),
+                        orgId: getRequestOrgId() ?? null,
+                        caller: "tool",
+                    });
                     if (result && result !== "(no output)") {
                         const screenText = typeof result === "string"
                             ? result
@@ -2008,11 +2080,11 @@ export function createProductionAgentHandler(options) {
         const effectiveTurnId = typeof requestTurnId === "string" && requestTurnId.trim()
             ? requestTurnId.trim()
             : runId;
+        const messageToPersist = typeof requestDisplayMessage === "string" &&
+            requestDisplayMessage.trim().length > 0
+            ? requestDisplayMessage
+            : requestMessage;
         if (options.onRunPrepared && !internalContinuation) {
-            const messageToPersist = typeof requestDisplayMessage === "string" &&
-                requestDisplayMessage.trim().length > 0
-                ? requestDisplayMessage
-                : requestMessage;
             await options.onRunPrepared({
                 runId,
                 threadId,
@@ -2020,7 +2092,87 @@ export function createProductionAgentHandler(options) {
                 attachments: requestAttachments,
             });
         }
-        startRun(runId, effectiveThreadId, async (send, signal) => {
+        const trackedProgressOwner = trackInRunsTray === true && ownerEmail ? ownerEmail : null;
+        const trackedProgressRunId = trackedProgressOwner
+            ? backgroundChatProgressRunId(effectiveTurnId)
+            : null;
+        const trackedProgressMetadata = trackedProgressRunId
+            ? {
+                kind: "agent-chat-background",
+                threadId: effectiveThreadId,
+                surfaceUrl: `agent-native://threads/${encodeURIComponent(effectiveThreadId)}`,
+                turnId: effectiveTurnId,
+            }
+            : null;
+        const completeTrackedProgressRun = async (run, completionError) => {
+            if (!trackedProgressRunId || !trackedProgressOwner)
+                return;
+            if (!completionError && endsAtInternalContinuationBoundary(run)) {
+                return;
+            }
+            const terminalStatus = run.status === "aborted"
+                ? "cancelled"
+                : run.status === "errored" || completionError
+                    ? "failed"
+                    : "succeeded";
+            const step = terminalStatus === "succeeded"
+                ? "Agent finished."
+                : terminalStatus === "cancelled"
+                    ? "Agent run was cancelled."
+                    : "Agent stopped with an error.";
+            await completeProgressRun(trackedProgressRunId, trackedProgressOwner, terminalStatus, {
+                step,
+                metadata: {
+                    ...(trackedProgressMetadata ?? {}),
+                    runId: run.runId,
+                },
+            }).catch(() => { });
+        };
+        let lastTrackedProgressUpdateAt = 0;
+        const updateTrackedProgressFromEvent = (event) => {
+            if (!trackedProgressRunId || !trackedProgressOwner)
+                return;
+            const step = progressStepFromAgentChatEvent(event);
+            if (!step)
+                return;
+            const now = Date.now();
+            if (now - lastTrackedProgressUpdateAt < 15_000)
+                return;
+            lastTrackedProgressUpdateAt = now;
+            void updateRunProgress(trackedProgressRunId, trackedProgressOwner, {
+                step,
+                metadata: {
+                    ...(trackedProgressMetadata ?? {}),
+                    runId,
+                },
+            }).catch(() => { });
+        };
+        if (trackedProgressRunId && trackedProgressOwner && !internalContinuation) {
+            await startProgressRun({
+                id: trackedProgressRunId,
+                owner: trackedProgressOwner,
+                title: messageToPersist,
+                step: "Starting agent.",
+                metadata: trackedProgressMetadata ?? undefined,
+            }).catch(() => { });
+        }
+        const handleRunComplete = options.onRunComplete || trackedProgressRunId
+            ? async (run) => {
+                try {
+                    await options.onRunComplete?.(run, threadId);
+                }
+                catch (err) {
+                    await completeTrackedProgressRun(run, err);
+                    throw err;
+                }
+                await completeTrackedProgressRun(run);
+            }
+            : undefined;
+        startRun(runId, effectiveThreadId, async (rawSend, signal) => {
+            const send = (event) => {
+                rawSend(event);
+                updateTrackedProgressFromEvent(event);
+            };
             send({ type: "activity", label: "Starting agent" });
             // Notify listeners that a run has started (used by agent teams)
             if (options.onRunStart) {
@@ -2322,9 +2474,7 @@ export function createProductionAgentHandler(options) {
             catch {
                 // Usage recording failed — don't break the run
             }
-        }, options.onRunComplete
-            ? (run) => options.onRunComplete(run, threadId)
-            : undefined, {
+        }, handleRunComplete, {
             softTimeoutMs: options.runSoftTimeoutMs,
             useHostedSoftTimeoutDefault: true,
             // Fold continuation runs of one logical turn onto a single durable