@tea-agent/loop-agent 0.12.0 → 0.13.0-beta.0

package/dist/workflows/dag/dynamic-runtime/map.js

@@ -19,6 +19,7 @@ export function buildExpandedChildTask(input) {
         executor: child.executor,
         role: child.role,
         skills: child.skills,
+        toolProfile: child.toolProfile,
         writePolicy: child.writePolicy,
         allowedPaths: renderDynamicPatternList(child.allowedPaths, item, index, expansion.itemName) ?? [],
         forbiddenPaths: renderDynamicPatternList(child.forbiddenPaths, item, index, expansion.itemName) ?? [],
@@ -140,10 +141,72 @@ export async function executeDynamicMapExpansion(input) {
     };
     await writeDagRunJsonArtifact(input.runDir, `expansions/${input.task.id}.expansion.json`, manifest);
     await input.persistState();
-    for (const child of children) {
+    const blockedChildren = [];
+    const tokenBudget = input.expansion.tokenBudget;
+    const isBudgetBlockedRecord = (record) => record?.status === "SKIPPED" &&
+        typeof record.stderr === "string" &&
+        record.stderr.includes("token-budget-exhausted");
+    let totalTokensUsed = 0;
+    let tokenBudgetExhausted = false;
+    // Resume-safe seed: count completed children and preserve prior budget skips.
+    if (tokenBudget !== undefined) {
+        for (const child of children) {
+            const record = input.state.nodes[child.id];
+            if (record?.status === "FINISHED") {
+                totalTokensUsed += record.tokensUsed ?? 0;
+            }
+            else if (isBudgetBlockedRecord(record)) {
+                if (!blockedChildren.some((entry) => entry.nodeId === child.id)) {
+                    blockedChildren.push({
+                        nodeId: child.id,
+                        reason: "token-budget-exhausted",
+                    });
+                }
+            }
+        }
+        if ((tokenBudget.maxTotalTokens !== undefined &&
+            totalTokensUsed >= tokenBudget.maxTotalTokens) ||
+            blockedChildren.length > 0) {
+            tokenBudgetExhausted = true;
+        }
+    }
+    for (let childIndex = 0; childIndex < children.length; childIndex += 1) {
+        const child = children[childIndex];
         const childRecord = input.state.nodes[child.id];
+        // Never re-run completed or budget-blocked children on resume.
         if (childRecord?.status === "FINISHED")
             continue;
+        if (isBudgetBlockedRecord(childRecord))
+            continue;
+        if (tokenBudget !== undefined &&
+            (tokenBudgetExhausted ||
+                (tokenBudget.maxTotalTokens !== undefined &&
+                    totalTokensUsed >= tokenBudget.maxTotalTokens))) {
+            for (const remaining of children.slice(childIndex)) {
+                const record = input.state.nodes[remaining.id];
+                if (!record || record.status === "FINISHED")
+                    continue;
+                if (isBudgetBlockedRecord(record)) {
+                    if (!blockedChildren.some((entry) => entry.nodeId === remaining.id)) {
+                        blockedChildren.push({
+                            nodeId: remaining.id,
+                            reason: "token-budget-exhausted",
+                        });
+                    }
+                    continue;
+                }
+                record.status = "SKIPPED";
+                record.stderr = "blocked: token-budget-exhausted";
+                if (!blockedChildren.some((entry) => entry.nodeId === remaining.id)) {
+                    blockedChildren.push({
+                        nodeId: remaining.id,
+                        reason: "token-budget-exhausted",
+                    });
+                }
+            }
+            await input.persistState();
+            break;
+        }
         await executeDagNode({
             nodeId: child.id,
             tasksById: input.tasksById,
@@ -159,8 +222,25 @@ export async function executeDynamicMapExpansion(input) {
                 throw new Error(`dynamic child node ${child.id} requested a human pause; map_agent children do not support pause in v0`);
             },
         });
+        const executedTokens = input.state.nodes[child.id]?.tokensUsed ?? 0;
+        totalTokensUsed += executedTokens;
+        if (tokenBudget &&
+            ((tokenBudget.maxTokensPerCase !== undefined &&
+                executedTokens >= tokenBudget.maxTokensPerCase) ||
+                (tokenBudget.maxTotalTokens !== undefined &&
+                    totalTokensUsed >= tokenBudget.maxTotalTokens))) {
+            tokenBudgetExhausted = true;
+        }
     }
-    const failedChildren = childNodeIds.filter((nodeId) => input.state.nodes[nodeId]?.status !== "FINISHED");
+    const budgetBlockedIds = new Set(blockedChildren.map((entry) => entry.nodeId));
+    const failedChildren = childNodeIds.filter((nodeId) => {
+        const record = input.state.nodes[nodeId];
+        if (!record || record.status === "FINISHED")
+            return false;
+        if (budgetBlockedIds.has(nodeId) || isBudgetBlockedRecord(record))
+            return false;
+        return true;
+    });
     const aggregate = {
         workflowNodeId: input.expansion.workflowNodeId,
         itemCount: items.length,
@@ -172,9 +252,17 @@ export async function executeDynamicMapExpansion(input) {
             stdout: input.state.nodes[nodeId]?.stdout,
             output: parseJsonFromText(input.state.nodes[nodeId]?.stdout),
             assistantText: input.state.nodes[nodeId]?.assistantText,
+            blocked: blockedChildren.find((child) => child.nodeId === nodeId)?.reason ??
+                (isBudgetBlockedRecord(input.state.nodes[nodeId])
+                    ? "token-budget-exhausted"
+                    : undefined),
         })),
+        tokensUsed: totalTokensUsed,
     };
     return {
+        // A post-case token stop is an expected bounded outcome; downstream review
+        // must receive its aggregate rather than be skipped with the map barrier.
+        // Real child failures remain fail-closed even when later cases are budget-blocked.
         ok: failedChildren.length === 0,
         stdout: JSON.stringify(aggregate),
         stderr: failedChildren.length > 0

package/dist/workflows/dag/failure-routing.js

@@ -22,6 +22,10 @@ const FOLLOW_UP_BY_PRODUCT_LINE = {
     NeedsHuman: "human-review",
     Unknown: "human triage",
 };
+function isFrontendDesignGateNode(nodeId) {
+    const lower = nodeId.toLowerCase();
+    return lower.includes("design-gate");
+}
 function routeToProductLine(input) {
     const normalized = input.normalizedFailureCategory;
     if (!normalized || normalized === "success")
@@ -47,6 +51,9 @@ function routeToProductLine(input) {
             if (nodeId.includes("test") || raw.includes("test-bug")) {
                 return "TestBug";
             }
+            if (isFrontendDesignGateNode(nodeId)) {
+                return "ContractMismatch";
+            }
             return "ProductBug";
         case "static-error":
             return "SpecUnclear";
@@ -75,8 +82,12 @@ export function routeDagFailure(input) {
     const productLineFailureCategory = routeToProductLine(input);
     if (!productLineFailureCategory)
         return {};
+    const recommendedFollowUp = productLineFailureCategory === "ContractMismatch" &&
+        isFrontendDesignGateNode(input.nodeId ?? "")
+        ? "frontend-plan-revision-and-rerun"
+        : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
     return {
         productLineFailureCategory,
-        recommendedFollowUp: FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory],
+        recommendedFollowUp,
     };
 }