@agent-native/core 0.35.0 → 0.35.3

package/dist/server/agent-teams.js

@@ -240,6 +240,11 @@ async function failReconciledTask(task, ownerEmail, message, progressStatus = "f
     await completeAgentTeamRun(task.taskId, "failed").catch(() => { });
     return task;
 }
+function subAgentDispatchFailureMessage(err) {
+    return err instanceof Error
+        ? `Failed to start sub-agent: ${err.message}`
+        : "Failed to start sub-agent.";
+}
 /**
  * Re-fire a dropped self-dispatch. When the queue row is still queued/running
  * but its heartbeat has gone stale (the self-fire never landed, or the
@@ -262,8 +267,8 @@ async function refireStuckAgentTeamRunIfNeeded(task, dispatch, event) {
             body: { mode: dispatch.continuationCount > 0 ? "continue" : "start" },
         });
     }
-    catch {
-        // best-effort
+    catch (err) {
+        await failReconciledTask(task, dispatch.ownerEmail, subAgentDispatchFailureMessage(err));
     }
 }
 /**
@@ -362,10 +367,42 @@ function generateTaskId() {
 function taskRunId(taskId) {
     return `run-task-${taskId}`;
 }
+function taskRunChunkId(taskId, chunk) {
+    return `${taskRunId(taskId)}-c${chunk}`;
+}
 function taskIdFromBackgroundRunId(runId) {
-    return runId.startsWith("run-task-")
+    const taskId = runId.startsWith("run-task-")
         ? runId.slice("run-task-".length)
         : runId;
+    const chunkTaskId = taskId.match(/^(.*)-c\d+$/)?.[1];
+    // Public background run ids are stable base ids. Only strip a chunk suffix
+    // when the caller passed a live run-manager chunk id.
+    return chunkTaskId && getRun(runId)?.status === "running"
+        ? chunkTaskId
+        : taskId;
+}
+function runningInMemoryTaskRunId(taskId) {
+    const baseRunId = taskRunId(taskId);
+    for (let i = MAX_AGENT_TEAM_CONTINUATIONS; i >= 0; i -= 1) {
+        const chunkRunId = taskRunChunkId(taskId, i);
+        if (getRun(chunkRunId)?.status === "running")
+            return chunkRunId;
+    }
+    if (getRun(baseRunId)?.status === "running")
+        return baseRunId;
+    return baseRunId;
+}
+async function durableActiveTaskRunId(taskId) {
+    try {
+        const dispatch = await getAgentTeamRunDispatchState(taskId);
+        if (dispatch?.status === "queued" || dispatch?.status === "running") {
+            return taskRunChunkId(taskId, dispatch.continuationCount);
+        }
+    }
+    catch {
+        // Fall back to in-memory state if queue state is temporarily unavailable.
+    }
+    return runningInMemoryTaskRunId(taskId);
 }
 function mapTaskStatusToBackgroundStatus(status) {
     return status;
@@ -620,24 +657,33 @@ function summarizeAgentChatEvent(event) {
             return null;
     }
 }
-export function toAgentTaskBackgroundTranscriptEvent(runId, event) {
+export function toAgentTaskBackgroundTranscriptEvent(runId, event, options = {}) {
     const summary = summarizeAgentChatEvent(event);
     if (!summary)
         return null;
+    const sourceRunId = options.sourceRunId ?? runId;
+    const eventId = `${sourceRunId}:${event.seq}`;
+    const seq = options.seq ?? event.seq;
+    const metadata = {
+        ...(summary.metadata ?? {}),
+        seq,
+        sourceSeq: event.seq,
+        ...(sourceRunId === runId ? {} : { sourceRunId }),
+    };
     return {
         schemaVersion: 1,
-        id: `${runId}:${event.seq}`,
+        id: eventId,
         runId,
         kind: summary.kind,
         source: "hosted-agent-team",
         sourceRecord: {
             type: "agent-team-run-event",
-            id: `${runId}:${event.seq}`,
-            seq: event.seq,
+            id: eventId,
+            seq,
         },
         message: summary.message,
         createdAt: new Date().toISOString(),
-        metadata: summary.metadata,
+        metadata,
     };
 }
 /**
@@ -749,10 +795,7 @@ export async function spawnTask(opts) {
         // Enqueue/dispatch failed outright — surface as an errored task rather
         // than a ghost "running" one. (A dropped self-fire that still enqueued is
         // recovered by the reconcile stuck-refire path.)
-        const message = err instanceof Error
-            ? `Failed to start sub-agent: ${err.message}`
-            : "Failed to start sub-agent.";
-        await failReconciledTask(task, opts.ownerEmail, message);
+        await failReconciledTask(task, opts.ownerEmail, subAgentDispatchFailureMessage(err));
     }
     return task;
 }
@@ -998,12 +1041,17 @@ export async function processAgentTeamRun(opts) {
                             await saveTask(task);
                             if (ownerEmail)
                                 await updateTaskProgressRun(task, ownerEmail);
-                            await fireInternalDispatch({
-                                event: opts.event,
-                                path: AGENT_TEAM_PROCESS_RUN_PATH,
-                                taskId: opts.taskId,
-                                body: { mode: "continue" },
-                            });
+                            try {
+                                await fireInternalDispatch({
+                                    event: opts.event,
+                                    path: AGENT_TEAM_PROCESS_RUN_PATH,
+                                    taskId: opts.taskId,
+                                    body: { mode: "continue" },
+                                });
+                            }
+                            catch (err) {
+                                await failReconciledTask(task, ownerEmail || null, subAgentDispatchFailureMessage(err));
+                            }
                             return;
                         }
                         // Hit the cap — finalize with whatever was produced.
@@ -1046,17 +1094,44 @@ export async function getAgentTeamBackgroundRun(runId) {
         : null;
 }
 export async function listAgentTeamBackgroundTranscriptEvents(runId) {
-    const normalizedRunId = taskRunId(taskIdFromBackgroundRunId(runId));
-    const activeRun = getRun(normalizedRunId);
-    const events = activeRun
-        ? activeRun.events
-        : await getPersistedRunEvents(normalizedRunId);
-    return events
-        .map((event) => toAgentTaskBackgroundTranscriptEvent(normalizedRunId, event))
-        .filter((event) => Boolean(event));
+    const taskId = taskIdFromBackgroundRunId(runId);
+    const normalizedRunId = taskRunId(taskId);
+    const runIds = await transcriptRunIdsForTask(taskId);
+    const output = [];
+    let seq = 0;
+    for (const sourceRunId of runIds) {
+        const activeRun = getRun(sourceRunId);
+        const events = activeRun
+            ? activeRun.events
+            : await getPersistedRunEvents(sourceRunId);
+        for (const event of events) {
+            const transcriptEvent = toAgentTaskBackgroundTranscriptEvent(normalizedRunId, event, { seq, sourceRunId });
+            if (transcriptEvent) {
+                output.push(transcriptEvent);
+                seq += 1;
+            }
+        }
+    }
+    return output;
 }
 export function subscribeToAgentTeamBackgroundRun(runId, fromSeq = 0) {
-    return subscribeToRun(taskRunId(taskIdFromBackgroundRunId(runId)), fromSeq);
+    return subscribeToRun(runningInMemoryTaskRunId(taskIdFromBackgroundRunId(runId)), fromSeq);
+}
+async function transcriptRunIdsForTask(taskId) {
+    const baseRunId = taskRunId(taskId);
+    let continuationCount = 0;
+    try {
+        continuationCount =
+            (await getAgentTeamRunDispatchState(taskId))?.continuationCount ?? 0;
+    }
+    catch {
+        continuationCount = 0;
+    }
+    const ids = [baseRunId];
+    for (let i = 0; i <= continuationCount; i += 1) {
+        ids.push(taskRunChunkId(taskId, i));
+    }
+    return ids;
 }
 async function getPersistedRunEvents(runId) {
     const rows = await getRunEventsSince(runId, 0);
@@ -1149,7 +1224,7 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user") {
     if (task.status !== "running") {
         return { ok: false, error: "Task is not running" };
     }
-    abortRun(taskRunId(taskId), reason);
+    abortRun(await durableActiveTaskRunId(taskId), reason);
     task.status = "errored";
     task.summary =
         reason === "user" ? "Task stopped." : `Task stopped: ${reason}`;
@@ -1161,6 +1236,7 @@ export async function stopAgentTeamBackgroundRun(runId, reason = "user") {
     if (ownerEmail) {
         await completeTaskProgressRun(task, ownerEmail, "cancelled", task.summary);
     }
+    await completeAgentTeamRun(task.taskId, "failed");
     return { ok: true };
 }
 /** Mark a task as errored */