@agent-native/core 0.47.1 → 0.48.2

package/dist/server/agent-teams.js

@@ -21,7 +21,7 @@ import { getRunEventsSince } from "../agent/run-store.js";
 import { runAgentLoop, appendAgentLoopContinuation, } from "../agent/production-agent.js";
 import { buildAssistantMessage, foldAssistantTurn, threadDataToEngineMessages, } from "../agent/thread-data-builder.js";
 import { completeRun as completeProgressRun, startRun as startProgressRun, updateRunProgress, } from "../progress/registry.js";
-import { enqueueAgentTeamRun, claimAgentTeamRun, touchAgentTeamRun, bumpAgentTeamContinuation, completeAgentTeamRun, getAgentTeamRunDispatchState, listActiveAgentTeamTaskIdsForOwner, MAX_AGENT_TEAM_CONTINUATIONS, RUN_DISPATCH_STUCK_AFTER_MS, RUN_PROCESSING_STUCK_AFTER_MS, } from "./agent-teams-run-queue.js";
+import { enqueueAgentTeamRun, claimAgentTeamRun, touchAgentTeamRun, bumpAgentTeamContinuation, completeAgentTeamRun, getAgentTeamRunDispatchState, listActiveAgentTeamTaskIdsForOwner, MAX_AGENT_TEAM_CONTINUATIONS, MAX_AGENT_TEAM_NO_PROGRESS_CONTINUATIONS, RUN_DISPATCH_STUCK_AFTER_MS, RUN_PROCESSING_STUCK_AFTER_MS, } from "./agent-teams-run-queue.js";
 import { describeDbError } from "../db/client.js";
 import { fireInternalDispatch } from "./self-dispatch.js";
 import { resolveOrgIdForEmail } from "../org/context.js";
@@ -53,6 +53,85 @@ const TASK_PREFIX = "agent-task:";
 const THREAD_PREFIX = "agent-task-thread:";
 /** Key prefix for queued orchestrator→sub-agent messages. */
 const TASK_MESSAGE_PREFIX = "task-message:";
+/**
+ * Key prefix for durable completion-injection entries that tell the parent
+ * thread's next turn about a finished sub-agent. Pattern mirrors
+ * `TASK_MESSAGE_PREFIX` (appstate key → JSON payload consumed once).
+ *
+ * Key: `parent-completion:{parentThreadId}:{injectionId}`
+ * Value: `ParentCompletionInjection` JSON.
+ */
+const PARENT_COMPLETION_PREFIX = "parent-completion:";
+/** Max chars of the sub-agent summary to include inline in the injection.
+ * The orchestrator can always call read-result for the full output. */
+const PARENT_COMPLETION_INLINE_MAX = 2_000;
+function parentCompletionQueuePrefix(parentThreadId) {
+    return `${PARENT_COMPLETION_PREFIX}${parentThreadId}:`;
+}
+function generateInjectionId() {
+    return `inj-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/** Append a completion-injection entry to the parent thread's queue. */
+async function appendParentCompletionInjection(parentThreadId, task, terminal) {
+    const id = generateInjectionId();
+    const summaryExcerpt = terminal.summary.length > PARENT_COMPLETION_INLINE_MAX
+        ? terminal.summary.slice(0, PARENT_COMPLETION_INLINE_MAX)
+        : terminal.summary;
+    const injection = {
+        id,
+        taskId: task.taskId,
+        taskName: task.name,
+        status: terminal.taskStatus,
+        hitContinuationLimit: terminal.hitContinuationLimit ?? false,
+        summaryExcerpt,
+        fullSummaryAvailable: terminal.summary.length > PARENT_COMPLETION_INLINE_MAX,
+        timestamp: Date.now(),
+    };
+    await writeAppState(`${parentCompletionQueuePrefix(parentThreadId)}${id}`, injection);
+}
+/** Format a parent-completion injection as a human-readable orchestrator
+ * message. Mirrors `formatQueuedTaskMessages`. */
+function formatParentCompletionInjection(inj) {
+    const name = inj.taskName ? `"${inj.taskName}"` : `task ${inj.taskId}`;
+    const statusLine = inj.status === "completed"
+        ? inj.hitContinuationLimit
+            ? `completed (reached continuation limit — partial result)`
+            : `completed`
+        : `failed`;
+    const tail = inj.fullSummaryAvailable
+        ? `\n\n(Full output truncated — call \`agent-teams\` action "read-result" with taskId "${inj.taskId}" to retrieve the complete result.)`
+        : "";
+    return `Sub-agent ${name} ${statusLine}:\n\n${inj.summaryExcerpt}${tail}`;
+}
+/**
+ * Drain the parent-completion injection queue for a thread. Returns all
+ * pending injections and deletes them atomically. Exported so the agent-chat
+ * plugin can drain these into the orchestrator's next user-turn.
+ */
+export async function drainParentCompletionInjections(parentThreadId) {
+    const prefix = parentCompletionQueuePrefix(parentThreadId);
+    const entries = await listAppState(prefix);
+    if (entries.length === 0)
+        return [];
+    const injections = [];
+    for (const entry of entries) {
+        const v = entry.value;
+        if (typeof v.id === "string" &&
+            typeof v.taskId === "string" &&
+            typeof v.status === "string") {
+            injections.push(v);
+            await deleteAppState(entry.key);
+        }
+    }
+    return injections.sort((a, b) => a.timestamp - b.timestamp);
+}
+/**
+ * Format all drained parent-completion injections as a single user-turn
+ * message to inject into the orchestrator thread.
+ */
+export function formatParentCompletionInjections(injections) {
+    return injections.map(formatParentCompletionInjection).join("\n\n---\n\n");
+}
 const TASK_RUN_MISSING_GRACE_MS = 60_000;
 function taskMessageQueuePrefix(taskId) {
     return `${TASK_MESSAGE_PREFIX}${taskId}:`;
@@ -332,7 +411,7 @@ async function reconcileTaskWithRun(task, event) {
     }
     if (runState?.status === "running")
         return task;
-    const ownerEmail = getRequestUserEmail();
+    const ownerEmail = getRequestUserEmail() ?? null;
     if (runState?.status === "completed") {
         return await completeReconciledTask(task, ownerEmail);
     }
@@ -494,7 +573,14 @@ async function completeTaskProgressRun(task, ownerEmail, status, step) {
         // best-effort
     }
 }
-function resolveTaskCompletion(run, accumulatedText) {
+/**
+ * Maximum characters stored in `task.summary` (the full result surfaced to the
+ * orchestrator via `read-result`). Generous enough to avoid destroying long
+ * sub-agent output; matches the tool-result truncation cap used in the main
+ * production-agent loop.
+ */
+const TASK_SUMMARY_MAX_CHARS = 50_000;
+function resolveTaskCompletion(run, accumulatedText, options) {
     const text = accumulatedText.trim();
     if (run.status === "aborted") {
         const stopped = run.abortReason && run.abortReason !== "user"
@@ -509,6 +595,7 @@ function resolveTaskCompletion(run, accumulatedText) {
         };
     }
     if (run.status === "errored") {
+        // Keep a reasonable tail for error context; errors are rarely huge.
         const failed = text.slice(-500) || "Task failed.";
         return {
             taskStatus: "errored",
@@ -518,7 +605,15 @@ function resolveTaskCompletion(run, accumulatedText) {
             error: failed,
         };
     }
-    const summary = text.slice(-1000) || "Task completed successfully.";
+    // Store up to TASK_SUMMARY_MAX_CHARS so the orchestrator's read-result tool
+    // can access the full output without truncation. If the absolute continuation
+    // cap was hit, mark the result so the orchestrator can distinguish it.
+    let summary = text.length > TASK_SUMMARY_MAX_CHARS
+        ? text.slice(-TASK_SUMMARY_MAX_CHARS)
+        : text || "Task completed successfully.";
+    if (options?.hitContinuationLimit) {
+        summary = `[hit-continuation-limit]\n\n${summary}`;
+    }
     return {
         taskStatus: "completed",
         summary,
@@ -895,8 +990,10 @@ async function persistTaskThreadData(task, description, run, runId, turnId) {
     }
 }
 /** Mark a sub-agent task terminal: task record, progress row, and queue row. */
-async function finalizeAgentTeamRun(task, run, ownerEmail, fullText) {
-    const terminal = resolveTaskCompletion(run, fullText);
+async function finalizeAgentTeamRun(task, run, ownerEmail, fullText, options) {
+    const terminal = resolveTaskCompletion(run, fullText, {
+        hitContinuationLimit: options?.hitContinuationLimit,
+    });
     task.status = terminal.taskStatus;
     task.summary = terminal.summary;
     task.error = terminal.error;
@@ -906,7 +1003,51 @@ async function finalizeAgentTeamRun(task, run, ownerEmail, fullText) {
     if (ownerEmail) {
         await completeTaskProgressRun(task, ownerEmail, terminal.progressStatus, terminal.progressStep);
     }
-    await completeAgentTeamRun(task.taskId, terminal.taskStatus === "completed" ? "done" : "failed");
+    await completeAgentTeamRun(task.taskId, terminal.taskStatus === "completed" ? "done" : "failed", options?.claimedAttempts);
+    // ── Completion loop: notify the parent thread ─────────────────────────────
+    // Append a durable injection to the parent thread's queue so the
+    // orchestrator automatically sees the result at its next turn start.
+    // Also write a NotificationsBell entry so the user sees a badge.
+    if (task.parentThreadId) {
+        try {
+            await appendParentCompletionInjection(task.parentThreadId, task, {
+                taskStatus: terminal.taskStatus,
+                summary: terminal.summary,
+                hitContinuationLimit: options?.hitContinuationLimit,
+            });
+        }
+        catch {
+            // best-effort — a queue write failure must not break finalization
+        }
+    }
+    if (ownerEmail) {
+        try {
+            const { insertNotification } = await import("../notifications/store.js");
+            const name = task.name ?? task.description.slice(0, 60);
+            const statusLabel = terminal.taskStatus === "completed"
+                ? options?.hitContinuationLimit
+                    ? "finished (hit limit)"
+                    : "finished"
+                : "failed";
+            await insertNotification({
+                owner: ownerEmail,
+                severity: terminal.taskStatus === "completed" ? "info" : "warning",
+                title: `Sub-agent "${name}" ${statusLabel}`,
+                body: terminal.summary.slice(0, 300) || undefined,
+                metadata: {
+                    kind: "agent-team-complete",
+                    taskId: task.taskId,
+                    threadId: task.threadId,
+                    ...(task.parentThreadId
+                        ? { parentThreadId: task.parentThreadId }
+                        : {}),
+                },
+            });
+        }
+        catch {
+            // best-effort — a notification write failure must not break finalization
+        }
+    }
 }
 /**
  * Execute one chunk of a queued sub-agent run in a fresh function invocation.
@@ -990,11 +1131,16 @@ export async function processAgentTeamRun(opts) {
         await saveTask(task);
         if (ownerEmail)
             await updateTaskProgressRun(task, ownerEmail);
+        // The attempts value at claim-time is the fencing token. All queue
+        // writes (heartbeat, bump, complete) include AND attempts = claimedAttempts
+        // so a superseded invocation that was re-claimed by a stuck-refire cannot
+        // accidentally touch the new invocation's row.
+        const claimedAttempts = claimed.attempts;
         const heartbeat = setInterval(() => {
             // Best-effort: a dropped Neon WebSocket (Lambda freeze/thaw) rejects
             // with a raw ErrorEvent; a floating rejection here surfaces as an
             // unhandled promise rejection, so it must be caught and logged.
-            touchAgentTeamRun(opts.taskId).catch((err) => {
+            touchAgentTeamRun(opts.taskId, claimedAttempts).catch((err) => {
                 console.warn(`[agent-teams] heartbeat update failed for task ${opts.taskId}:`, describeDbError(err));
             });
         }, RUN_QUEUE_HEARTBEAT_MS);
@@ -1002,6 +1148,10 @@ export async function processAgentTeamRun(opts) {
         let accumulatedText = "";
         let lastProgressSent = 0;
         const PROGRESS_INTERVAL_MS = 2000;
+        // Track no-progress continuation budget (Fix 3).
+        let consecutiveNoProgressChunks = opts.noProgressCount ?? 0;
+        // Capture loop usage for token accounting (Fix 4).
+        let chunkUsage = null;
         await new Promise((resolve) => {
             startRun(runId, task.threadId, async (send, signal) => {
                 const wrappedSend = (event) => {
@@ -1027,7 +1177,7 @@ export async function processAgentTeamRun(opts) {
                     }
                 };
                 await runWithRequestContext({ userEmail: ownerEmail || undefined, orgId: orgId ?? undefined }, async () => {
-                    await runAgentLoop({
+                    chunkUsage = await runAgentLoop({
                         engine: config.engine,
                         model: config.model,
                         systemPrompt,
@@ -1043,14 +1193,57 @@ export async function processAgentTeamRun(opts) {
                 clearInterval(heartbeat);
                 try {
                     const fullText = await persistTaskThreadData(task, payload.description, run, runId, turnId);
+                    // Record token usage for this chunk (Fix 4).
+                    if (chunkUsage && ownerEmail) {
+                        try {
+                            const u = chunkUsage;
+                            if (u.inputTokens > 0 ||
+                                u.outputTokens > 0 ||
+                                u.cacheReadTokens > 0 ||
+                                u.cacheWriteTokens > 0) {
+                                const { recordUsage } = await import("../usage/store.js");
+                                const label = payload.name
+                                    ? `agent-team:${payload.name}`
+                                    : "agent-team";
+                                await recordUsage({
+                                    ownerEmail,
+                                    inputTokens: u.inputTokens,
+                                    outputTokens: u.outputTokens,
+                                    cacheReadTokens: u.cacheReadTokens,
+                                    cacheWriteTokens: u.cacheWriteTokens,
+                                    model: u.model,
+                                    label,
+                                });
+                            }
+                        }
+                        catch {
+                            // Usage recording failed — don't break the run
+                        }
+                    }
                     // A soft-timeout boundary means the host function wall is near and
                     // the partial turn is checkpointed in thread_data — self-fire the
                     // next continuation chunk (server-side analog of the client re-POST
                     // that continues the main chat) instead of finalizing.
                     const reachedBoundary = (run.events ?? []).some((e) => e.event.type === "auto_continue");
                     if (reachedBoundary) {
-                        const count = await bumpAgentTeamContinuation(opts.taskId);
-                        if (count !== null && count <= MAX_AGENT_TEAM_CONTINUATIONS) {
+                        // Progress check (Fix 3): count substantive events in this chunk.
+                        // Any text or tool activity counts as progress. An empty chunk
+                        // (only auto_continue with no actual work) is non-progressing.
+                        const substantiveEvents = (run.events ?? []).filter((e) => e.event.type === "text" ||
+                            e.event.type === "tool_start" ||
+                            e.event.type === "tool_done").length;
+                        if (substantiveEvents === 0) {
+                            consecutiveNoProgressChunks += 1;
+                        }
+                        else {
+                            consecutiveNoProgressChunks = 0;
+                        }
+                        const hitNoProgressLimit = consecutiveNoProgressChunks >=
+                            MAX_AGENT_TEAM_NO_PROGRESS_CONTINUATIONS;
+                        const count = await bumpAgentTeamContinuation(opts.taskId, claimedAttempts);
+                        if (count !== null &&
+                            count <= MAX_AGENT_TEAM_CONTINUATIONS &&
+                            !hitNoProgressLimit) {
                             task.currentStep = "Continuing sub-agent";
                             task.preview = (fullText || accumulatedText).slice(-800);
                             await saveTask(task);
@@ -1061,7 +1254,10 @@ export async function processAgentTeamRun(opts) {
                                     event: opts.event,
                                     path: AGENT_TEAM_PROCESS_RUN_PATH,
                                     taskId: opts.taskId,
-                                    body: { mode: "continue" },
+                                    body: {
+                                        mode: "continue",
+                                        noProgressCount: consecutiveNoProgressChunks,
+                                    },
                                 });
                             }
                             catch (err) {
@@ -1069,9 +1265,13 @@ export async function processAgentTeamRun(opts) {
                             }
                             return;
                         }
-                        // Hit the cap — finalize with whatever was produced.
+                        // Hit the absolute cap or no-progress limit — finalize with an
+                        // explicit marker so the orchestrator can distinguish this from a
+                        // clean completion.
+                        await finalizeAgentTeamRun(task, run, ownerEmail || null, fullText || accumulatedText, { hitContinuationLimit: true, claimedAttempts });
+                        return;
                     }
-                    await finalizeAgentTeamRun(task, run, ownerEmail || null, fullText || accumulatedText);
+                    await finalizeAgentTeamRun(task, run, ownerEmail || null, fullText || accumulatedText, { claimedAttempts });
                 }
                 finally {
                     resolve();