@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.11

package/dist/executors/dag-pi/sessions/scout-parallel.js

@@ -0,0 +1,197 @@
+/** DAG Pi scout 并行分片会话：结果聚合、串行结果合并与 completedShards 缓存。 */
+import path from "node:path";
+import { observeFrontendSession } from "../../../workflows/dag/frontend-session-budget.js";
+import { createFrontendScoutEvidenceTools } from "../tools/scout-evidence-tools.js";
+export function aggregateParallelPiResults(results) {
+    const first = results[0];
+    const failed = results.find((result) => !result.ok);
+    const representative = failed ?? first;
+    return {
+        ...representative,
+        ok: failed === undefined,
+        failureCategory: failed?.failureCategory ?? "success",
+        durationMs: Math.max(...results.map((result) => result.durationMs), 0),
+        exitCode: failed ? failed.exitCode : 0,
+        stderr: results.map((result) => result.stderr).filter(Boolean).join("\n"),
+        tokensUsed: results.reduce((total, result) => total + result.tokensUsed, 0),
+        parsedEvents: results.reduce((total, result) => total + result.parsedEvents, 0),
+        attemptedModels: [
+            ...new Set(results.flatMap((result) => result.attemptedModels)),
+        ],
+        fallbackUsed: results.some((result) => result.fallbackUsed),
+        timedOut: results.some((result) => result.timedOut),
+    };
+}
+export function combineSequentialPiResults(first, second) {
+    return {
+        ...second,
+        durationMs: first.durationMs + second.durationMs,
+        stderr: [first.stderr, second.stderr].filter(Boolean).join("\n"),
+        tokensUsed: first.tokensUsed + second.tokensUsed,
+        parsedEvents: first.parsedEvents + second.parsedEvents,
+        attemptedModels: [
+            ...new Set([...first.attemptedModels, ...second.attemptedModels]),
+        ],
+        fallbackUsed: first.fallbackUsed || second.fallbackUsed,
+        timedOut: first.timedOut || second.timedOut,
+    };
+}
+export async function runFrontendScoutParallelSessions(input) {
+    const [{ createTypedEventStore }] = await Promise.all([
+        import("../../../workflows/dag/frontend-typed-event-store.js"),
+    ]);
+    const shards = [
+        {
+            id: "surface",
+            toolName: "record_target_surface",
+            instruction: [
+                "PARALLEL SCOUT SHARD — target surface only.",
+                "Inspect routes, entrypoints, implementation ownership, data source, and existing test entrypoints. Inspect project source/config first; do not recursively explore dependency internals merely to reconfirm standard test-runner behavior. If a concrete required capability cannot be established from project evidence, report the precise gap.",
+                "Call record_target_surface exactly once with the complete runtime-evidenced surface. Do not call record_design_evidence.",
+            ].join(" "),
+        },
+        {
+            id: "design",
+            toolName: "record_design_evidence",
+            instruction: [
+                "PARALLEL SCOUT SHARD — design evidence only.",
+                "Inspect project-owned frontend framework, styling/theme conventions, reusable components, and relevant design/spec files. The surface shard owns test-runner/environment discovery; do not duplicate its Vitest/happy-dom investigation. Stop discovery once the design evidence is sufficient and commit it.",
+                "Call record_design_evidence for the evidence you actually read. Do not call record_target_surface.",
+            ].join(" "),
+        },
+    ];
+    const outcomes = await Promise.all(shards.map(async (shard) => {
+        const cacheKey = JSON.stringify([input.runDir, input.nodeId, shard.id, input.sessionOptions.modelConfig, input.observation?.model, input.observation?.sourceDigest, input.sourceDeclaredPaths]);
+        const cached = input.completedShards?.get(cacheKey);
+        if (cached)
+            return { shard, facts: cached.facts, result: { ...cached.result, durationMs: 0, tokensUsed: 0, parsedEvents: 0, attemptedModels: [], fallbackUsed: false } };
+        let shardTools;
+        let shardResult;
+        try {
+            const store = createTypedEventStore();
+            const shardNodeId = `${input.nodeId}/parallel/${shard.id}`;
+            shardTools = await createFrontendScoutEvidenceTools({
+                attemptId: `${input.attemptId}:parallel:${shard.id}`,
+                store,
+                runDir: input.runDir,
+                nodeId: shardNodeId,
+                workspaceRoot: input.workspaceRoot,
+                sourceDeclaredPaths: input.sourceDeclaredPaths,
+            });
+            const customTools = shardTools.customTools.filter((tool) => typeof tool === "object" &&
+                tool !== null &&
+                tool.name === shard.toolName);
+            const sessionOptions = {
+                ...input.sessionOptions,
+                sessionEventsPath: path.join(input.runDir, shardNodeId, "session-events.jsonl"),
+            };
+            const prompt = `${input.basePrompt}\n\n${shard.instruction}`;
+            const tools = [...customTools, ...(input.readBudgetTools ?? [])];
+            shardResult = await observeFrontendSession({
+                ...input.observation,
+                phase: `scout/parallel/${shard.id}`,
+                scopeIds: [shard.id],
+                prompt,
+                userMessage: sessionOptions.userMessage,
+                customTools: tools,
+                artifactPath: input.observation?.artifactPath ? `${input.observation.artifactPath}-${shard.id}.json` : undefined,
+                committedCount: () => shardTools?.committedFacts().length ?? 0,
+                durableCommittedCount: () => shardTools?.committedFacts().length ?? 0,
+            }, observer => input.piStepFn({
+                ...sessionOptions,
+                onAttemptObservation: observer,
+                prompt,
+                writerToolPolicy: {
+                    requireSdk: true,
+                    customTools: tools,
+                },
+            }));
+            await shardTools.flush();
+            const facts = shardTools.committedFacts();
+            const expectedKind = shard.id === "design" ? "design-evidence" : "target-surface";
+            if (shardResult.ok && facts.some(record => { const fact = record.fact; return fact.kind === expectedKind && (shard.id !== "surface" || fact.completeness === "complete"); })) {
+                input.completedShards?.set(cacheKey, { result: structuredClone(shardResult), facts: structuredClone(facts) });
+            }
+            return { shard, result: shardResult, tools: shardTools, facts };
+        }
+        catch (error) {
+            const crashMessage = `frontend scout parallel shard ${shard.id} crashed: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                shard,
+                tools: shardTools,
+                result: shardResult
+                    ? {
+                        ...shardResult,
+                        ok: false,
+                        failureCategory: shardResult.ok
+                            ? "invalid-output"
+                            : shardResult.failureCategory,
+                        stderr: [shardResult.stderr, crashMessage]
+                            .filter(Boolean)
+                            .join("\n"),
+                    }
+                    : {
+                        ok: false,
+                        assistantText: "",
+                        command: [],
+                        durationMs: 0,
+                        exitCode: null,
+                        failureCategory: "tool-policy",
+                        modelDisplay: "unknown",
+                        parsedEvents: 0,
+                        stderr: crashMessage,
+                        stdout: "",
+                        timedOut: false,
+                        attemptedModels: [],
+                        fallbackUsed: false,
+                        tokensUsed: 0,
+                    },
+            };
+        }
+    }));
+    const ordered = [...outcomes].sort((left, right) => left.shard.id.localeCompare(right.shard.id));
+    try {
+        for (const outcome of ordered) {
+            if (outcome.result.ok) {
+                await input.mainTools.adoptCommittedFacts(outcome.facts ?? outcome.tools?.committedFacts() ?? []);
+            }
+        }
+    }
+    catch (error) {
+        const aggregate = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...aggregate,
+            ok: false,
+            failureCategory: "invalid-output",
+            stderr: [
+                aggregate.stderr,
+                `frontend scout parallel fact merge failed: ${error instanceof Error ? error.message : String(error)}`,
+            ]
+                .filter(Boolean)
+                .join("\n"),
+        };
+    }
+    const failed = ordered.find((outcome) => !outcome.result.ok);
+    if (failed) {
+        const aggregate = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...aggregate,
+            ok: false,
+            stderr: `${aggregate.stderr}\nfrontend scout parallel shard failed: ${failed.shard.id}`.trim(),
+        };
+    }
+    const committedKinds = new Set(ordered.flatMap((outcome) => (outcome.facts ?? outcome.tools?.committedFacts() ?? [])
+        .map((record) => record.fact?.kind)
+        .filter((kind) => typeof kind === "string")));
+    const missing = ["target-surface", "design-evidence"].filter((kind) => !committedKinds.has(kind));
+    if (missing.length > 0) {
+        const fallback = aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+        return {
+            ...fallback,
+            ok: false,
+            failureCategory: "invalid-output",
+            stderr: `${fallback.stderr}\nfrontend scout parallel shards committed no ${missing.join(" or ")} fact`.trim(),
+        };
+    }
+    return aggregateParallelPiResults(ordered.map((outcome) => outcome.result));
+}