@bastani/atomic 0.8.31-alpha.5 → 0.9.0-alpha.2

package/dist/builtin/subagents/src/runs/foreground/execution-structured-retries.ts

@@ -0,0 +1,77 @@
+import type { AgentConfig } from "../../agents/agents.ts";
+import type { RunSyncOptions, SingleResult } from "../../shared/types.ts";
+import {
+	STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS,
+	formatStructuredOutputCorrectionPrompt,
+	isStructuredOutputContractError,
+	latestStructuredOutputToolErrorFromMessages,
+} from "../shared/structured-output.ts";
+import { emptyUsage, sumUsage } from "./execution-utils.ts";
+import { runSingleAttempt } from "./execution-attempt.ts";
+import type { RunSingleAttemptShared } from "./execution-attempt-types.ts";
+import { shouldSuppressIntermediateStructuredOutputFailureUpdate, type RunSyncUpdate } from "./execution-updates.ts";
+
+export async function runSingleAttemptWithStructuredOutputRetries(
+	runtimeCwd: string,
+	agent: AgentConfig,
+	task: string,
+	model: string | undefined,
+	options: RunSyncOptions,
+	shared: RunSingleAttemptShared,
+): Promise<SingleResult> {
+	let nextTask = task;
+	let correctiveAttempts = 0;
+	let finalResult: SingleResult | undefined;
+	const aggregateUsage = emptyUsage();
+	let totalToolCount = 0;
+	let totalDurationMs = 0;
+
+	while (true) {
+		const suppressIntermediateStructuredOutputFailure = options.structuredOutput !== undefined
+			&& correctiveAttempts < STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS
+			&& options.onUpdate !== undefined;
+		const attemptOptions = suppressIntermediateStructuredOutputFailure
+			? {
+				...options,
+				onUpdate: (update: RunSyncUpdate) => {
+					if (shouldSuppressIntermediateStructuredOutputFailureUpdate(update)) return;
+					options.onUpdate?.(update);
+				},
+			}
+			: options;
+		const result = await runSingleAttempt(runtimeCwd, agent, nextTask, model, attemptOptions, shared);
+		finalResult = result;
+		sumUsage(aggregateUsage, result.usage);
+		totalToolCount += result.progressSummary?.toolCount ?? 0;
+		totalDurationMs += result.progressSummary?.durationMs ?? 0;
+
+		if (!options.structuredOutput || !isStructuredOutputContractError(result.error)) break;
+		const correctionError = latestStructuredOutputToolErrorFromMessages(result.messages) ?? result.error ?? "Structured output contract failed.";
+		if (correctiveAttempts >= STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS) {
+			result.error = correctionError;
+			break;
+		}
+		correctiveAttempts += 1;
+		nextTask = formatStructuredOutputCorrectionPrompt({
+			originalTask: task,
+			error: correctionError,
+			attempt: correctiveAttempts,
+		});
+	}
+
+	const result = finalResult ?? {
+		agent: agent.name,
+		task,
+		exitCode: 1,
+		messages: [],
+		usage: emptyUsage(),
+		error: "Subagent did not produce a result.",
+	} satisfies SingleResult;
+	result.usage = aggregateUsage;
+	result.progressSummary = {
+		toolCount: totalToolCount,
+		tokens: aggregateUsage.input + aggregateUsage.output,
+		durationMs: totalDurationMs,
+	};
+	return result;
+}

package/dist/builtin/subagents/src/runs/foreground/execution-updates.ts

@@ -0,0 +1,34 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Details } from "../../shared/types.ts";
+import { isRetryableModelFailure } from "../shared/model-fallback.ts";
+import { isStructuredOutputContractError } from "../shared/structured-output.ts";
+
+export type RunSyncUpdate = AgentToolResult<Details>;
+
+function extractUpdateText(update: RunSyncUpdate): string | undefined {
+	const text = update.content
+		.map((item) => item.type === "text" ? item.text : undefined)
+		.filter((item): item is string => Boolean(item?.trim()))
+		.join("\n");
+	return text || undefined;
+}
+
+function terminalUpdateFailureText(update: RunSyncUpdate): string | undefined {
+	const result = update.details?.results?.[0];
+	if (!result) return undefined;
+	const progress = update.details?.progress?.[0];
+	const status = result.progress?.status ?? progress?.status;
+	if (status !== "failed") return undefined;
+	return result.error
+		?? result.progress?.error
+		?? progress?.error
+		?? extractUpdateText(update);
+}
+
+export function shouldSuppressIntermediateRetryableFailureUpdate(update: RunSyncUpdate): boolean {
+	return isRetryableModelFailure(terminalUpdateFailureText(update));
+}
+
+export function shouldSuppressIntermediateStructuredOutputFailureUpdate(update: RunSyncUpdate): boolean {
+	return isStructuredOutputContractError(terminalUpdateFailureText(update));
+}

package/dist/builtin/subagents/src/runs/foreground/execution-utils.ts

@@ -0,0 +1,56 @@
+import type { AgentProgress, SingleResult, Usage } from "../../shared/types.ts";
+
+export const artifactOutputByResult = new WeakMap<SingleResult, string>();
+export const modelFailureSignalByResult = new WeakMap<SingleResult, unknown>();
+
+export function emptyUsage(): Usage {
+	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+
+export function sumUsage(target: Usage, source: Usage): void {
+	target.input += source.input;
+	target.output += source.output;
+	target.cacheRead += source.cacheRead;
+	target.cacheWrite += source.cacheWrite;
+	target.cost += source.cost;
+	target.turns += source.turns;
+}
+
+export function appendRecentOutput(progress: AgentProgress, lines: string[]): void {
+	if (lines.length === 0) return;
+	progress.recentOutput.push(...lines.filter((line) => line.trim()));
+	if (progress.recentOutput.length > 50) {
+		progress.recentOutput.splice(0, progress.recentOutput.length - 50);
+	}
+}
+
+export function snapshotProgress(progress: AgentProgress): AgentProgress {
+	return {
+		...progress,
+		skills: progress.skills ? [...progress.skills] : undefined,
+		recentTools: progress.recentTools.map((tool) => ({ ...tool })),
+		recentOutput: [...progress.recentOutput],
+	};
+}
+
+export function snapshotResult(result: SingleResult, progress: AgentProgress): SingleResult {
+	return {
+		...result,
+		messages: result.outputMode === "file-only" && result.savedOutputPath ? undefined : result.messages ? [...result.messages] : undefined,
+		usage: { ...result.usage },
+		skills: result.skills ? [...result.skills] : undefined,
+		attemptedModels: result.attemptedModels ? [...result.attemptedModels] : undefined,
+		modelAttempts: result.modelAttempts
+			? result.modelAttempts.map((attempt) => ({
+				...attempt,
+				usage: attempt.usage ? { ...attempt.usage } : undefined,
+			}))
+			: undefined,
+		controlEvents: result.controlEvents ? result.controlEvents.map((event) => ({ ...event })) : undefined,
+		progress,
+		progressSummary: result.progressSummary ? { ...result.progressSummary } : undefined,
+		artifactPaths: result.artifactPaths ? { ...result.artifactPaths } : undefined,
+		truncation: result.truncation ? { ...result.truncation } : undefined,
+		outputReference: result.outputReference ? { ...result.outputReference } : undefined,
+	};
+}