@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/shared/structured-output.ts

@@ -1,150 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { APP_NAME } from "@bastani/atomic";
-import type { Message } from "@earendil-works/pi-ai/compat";
-import { Compile } from "typebox/compile";
-import type { JsonSchemaObject } from "../../shared/types.ts";
-
-const ENV_PREFIX = APP_NAME.toUpperCase();
-export const STRUCTURED_OUTPUT_SCHEMA_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_SCHEMA`;
-export const STRUCTURED_OUTPUT_CAPTURE_ENV = `${ENV_PREFIX}_SUBAGENT_STRUCTURED_OUTPUT_CAPTURE`;
-export const STRUCTURED_OUTPUT_TOOL_NAME = "structured_output";
-export const STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS = 3;
-export const STRUCTURED_OUTPUT_MISSING_ERROR =
-	"Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
-
-export interface StructuredOutputRuntime {
-	schema: JsonSchemaObject;
-	schemaPath: string;
-	outputPath: string;
-}
-
-export function assertJsonSchemaDescriptor(
-	schema: unknown,
-	label = "outputSchema",
-): asserts schema is JsonSchemaObject {
-	if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
-		throw new Error(`${label} must be a JSON Schema object descriptor.`);
-	}
-}
-
-export function createStructuredOutputRuntime(schema: JsonSchemaObject, baseDir?: string): StructuredOutputRuntime {
-	const rootDir = baseDir ?? os.tmpdir();
-	fs.mkdirSync(rootDir, { recursive: true });
-	const dir = fs.mkdtempSync(path.join(rootDir, "pi-subagent-structured-"));
-	const schemaPath = path.join(dir, "schema.json");
-	const outputPath = path.join(dir, "output.json");
-	fs.writeFileSync(schemaPath, JSON.stringify(schema), { mode: 0o600 });
-	return { schema, schemaPath, outputPath };
-}
-
-export function validateStructuredOutputValue(
-	schema: JsonSchemaObject,
-	value: unknown,
-): { status: "valid" } | { status: "invalid"; message: string } {
-	try {
-		const validator = (
-			Compile as (schema: unknown) => {
-				Check(value: unknown): boolean;
-				Errors(value: unknown): Iterable<{ instancePath?: string; message?: string }>;
-			}
-		)(schema);
-		if (validator.Check(value)) return { status: "valid" };
-		const errors = [...validator.Errors(value)].slice(0, 8).map((error) => {
-			const pathText = error.instancePath ? error.instancePath.replace(/^\//, "").replace(/\//g, ".") : "root";
-			return `${pathText}: ${error.message}`;
-		});
-		return { status: "invalid", message: errors.join("; ") || "schema validation failed" };
-	} catch (error) {
-		return {
-			status: "invalid",
-			message: `invalid outputSchema: ${error instanceof Error ? error.message : String(error)}`,
-		};
-	}
-}
-
-function textFromContent(content: unknown): string | undefined {
-	if (!Array.isArray(content)) return undefined;
-	const text = content
-		.map((block) => {
-			if (!block || typeof block !== "object") return "";
-			const record = block as { readonly type?: unknown; readonly text?: unknown };
-			return record.type === "text" && typeof record.text === "string" ? record.text : "";
-		})
-		.join("\n")
-		.trim();
-	return text.length > 0 ? text : undefined;
-}
-
-export function latestStructuredOutputToolErrorFromMessages(
-	messages: readonly Message[] | undefined,
-): string | undefined {
-	if (!messages) return undefined;
-	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = messages[index];
-		if (message?.role !== "toolResult") continue;
-		if (message.toolName !== STRUCTURED_OUTPUT_TOOL_NAME) continue;
-		if (message.isError !== true) continue;
-		return textFromContent(message.content) ?? "structured_output tool call failed schema validation.";
-	}
-	return undefined;
-}
-
-export function isStructuredOutputContractError(error: string | undefined): boolean {
-	if (error === undefined) return false;
-	return (
-		error === STRUCTURED_OUTPUT_MISSING_ERROR ||
-		error.startsWith("Structured output validation failed:") ||
-		error.startsWith("Failed to read structured output:")
-	);
-}
-
-export function formatStructuredOutputCorrectionPrompt(args: {
-	readonly originalTask: string;
-	readonly error: string;
-	readonly attempt: number;
-	readonly maxAttempts?: number;
-}): string {
-	const maxAttempts = args.maxAttempts ?? STRUCTURED_OUTPUT_MAX_CORRECTIVE_PROMPTS;
-	return [
-		"The previous response failed this subagent's structured-output contract.",
-		"",
-		`Corrective attempt ${args.attempt}/${maxAttempts}.`,
-		"",
-		"Error:",
-		args.error,
-		"",
-		"You must finish by calling the `structured_output` tool exactly once with arguments matching the registered schema.",
-		"Do not answer with plain JSON text, Markdown, or prose. If you attempted `structured_output` and validation failed, correct the tool arguments and call `structured_output` again.",
-		"If the requested work is already complete, do not redo side effects unnecessarily; just report the completed result through `structured_output`.",
-		"",
-		"Original task:",
-		args.originalTask,
-	].join("\n");
-}
-
-export function readStructuredOutput(runtime: StructuredOutputRuntime): { value?: unknown; error?: string } {
-	if (!fs.existsSync(runtime.outputPath)) {
-		return { error: STRUCTURED_OUTPUT_MISSING_ERROR };
-	}
-	try {
-		const value = JSON.parse(fs.readFileSync(runtime.outputPath, "utf-8")) as unknown;
-		const validation = validateStructuredOutputValue(runtime.schema, value);
-		if (validation.status === "invalid") {
-			return { error: `Structured output validation failed: ${validation.message}` };
-		}
-		return { value };
-	} catch (error) {
-		return { error: `Failed to read structured output: ${error instanceof Error ? error.message : String(error)}` };
-	}
-}
-
-export function cleanupStructuredOutputRuntime(runtime: StructuredOutputRuntime | undefined): void {
-	if (!runtime) return;
-	try {
-		fs.rmSync(path.dirname(runtime.schemaPath), { recursive: true, force: true });
-	} catch {
-		// Best-effort temp cleanup.
-	}
-}

package/dist/builtin/subagents/src/runs/shared/workflow-graph.ts

@@ -1,232 +0,0 @@
-import { type ChainStep, isDynamicParallelStep, isParallelStep, type SequentialStep } from "../../shared/settings.ts";
-import type {
-	SingleResult,
-	SubagentRunMode,
-	WorkflowGraphNode,
-	WorkflowGraphSnapshot,
-	WorkflowNodeStatus,
-} from "../../shared/types.ts";
-
-export interface WorkflowGraphBuildInput {
-	runId: string;
-	mode?: SubagentRunMode;
-	steps: ChainStep[];
-	results?: Array<Pick<SingleResult, "status" | "detached" | "interrupted" | "error">>;
-	currentFlatIndex?: number;
-	currentStepIndex?: number;
-	stepStatuses?: Array<{ status?: string; error?: string }>;
-	dynamicChildren?: Record<
-		number,
-		Array<{
-			agent: string;
-			label?: string;
-			flatIndex: number;
-			itemKey: string;
-			outputName?: string;
-			structured?: boolean;
-			error?: string;
-		}>
-	>;
-	dynamicGroupStatuses?: Record<number, { status: WorkflowNodeStatus; error?: string }>;
-}
-
-function normalizeStatus(status: string | undefined): WorkflowNodeStatus | undefined {
-	switch (status) {
-		case "complete":
-		case "completed":
-			return "completed";
-		case "running":
-			return "running";
-		case "failed":
-			return "failed";
-		case "paused":
-			return "paused";
-		case "detached":
-			return "detached";
-		case "pending":
-			return "pending";
-		default:
-			return undefined;
-	}
-}
-
-function resultStatus(
-	result: Pick<SingleResult, "status" | "detached" | "interrupted"> | undefined,
-): WorkflowNodeStatus | undefined {
-	if (!result) return undefined;
-	if (result.detached || result.status === "continued") return "detached";
-	if (result.interrupted || result.status === "interrupted") return "paused";
-	return result.status === "ok" ? "completed" : "failed";
-}
-
-function nodeStatus(input: WorkflowGraphBuildInput, flatIndex: number): WorkflowNodeStatus {
-	return (
-		normalizeStatus(input.stepStatuses?.[flatIndex]?.status) ??
-		resultStatus(input.results?.[flatIndex]) ??
-		(input.currentFlatIndex === flatIndex ? "running" : "pending")
-	);
-}
-
-function pushPhase(phases: WorkflowGraphSnapshot["phases"], phase: string | undefined, nodeId: string): void {
-	if (!phase) return;
-	let group = phases.find((candidate) => candidate.title === phase);
-	if (!group) {
-		group = { title: phase, nodeIds: [] };
-		phases.push(group);
-	}
-	group.nodeIds.push(nodeId);
-}
-
-function seqLabel(step: SequentialStep, stepIndex: number): string {
-	return step.label?.trim() || step.agent || `Step ${stepIndex + 1}`;
-}
-
-function summarizeParallelStatuses(statuses: WorkflowNodeStatus[]): WorkflowNodeStatus {
-	if (statuses.some((status) => status === "running")) return "running";
-	if (statuses.some((status) => status === "failed")) return "failed";
-	if (statuses.some((status) => status === "paused")) return "paused";
-	if (statuses.some((status) => status === "detached")) return "detached";
-	if (statuses.length > 0 && statuses.every((status) => status === "completed")) return "completed";
-	if (statuses.some((status) => status === "completed")) return "running";
-	return "pending";
-}
-
-export function buildWorkflowGraphSnapshot(input: WorkflowGraphBuildInput): WorkflowGraphSnapshot {
-	const nodes: WorkflowGraphNode[] = [];
-	const phases: WorkflowGraphSnapshot["phases"] = [];
-	let flatIndex = 0;
-	let currentNodeId: string | undefined;
-
-	for (let stepIndex = 0; stepIndex < input.steps.length; stepIndex++) {
-		const step = input.steps[stepIndex]!;
-		if (isParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
-				const task = step.parallel[taskIndex]!;
-				const status = nodeStatus(input, flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-agent-${taskIndex}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: task.phase,
-					label: task.label?.trim() || task.agent || `Agent ${taskIndex + 1}`,
-					status,
-					flatIndex,
-					stepIndex,
-					outputName: task.as,
-					structured: Boolean(task.outputSchema),
-					error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-				};
-				children.push(child);
-				pushPhase(phases, task.phase, childId);
-				if (status === "running" || input.currentFlatIndex === flatIndex) currentNodeId = childId;
-				flatIndex++;
-			}
-			const groupStatus = summarizeParallelStatuses(childStatuses);
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "parallel-group",
-				label: step.parallel.length === 1 ? "Parallel task" : `Parallel group (${step.parallel.length})`,
-				status: groupStatus,
-				stepIndex,
-				children,
-			});
-			continue;
-		}
-
-		if (isDynamicParallelStep(step)) {
-			const groupId = `step-${stepIndex}`;
-			const materialized = input.dynamicChildren?.[stepIndex] ?? [];
-			const groupOverride = input.dynamicGroupStatuses?.[stepIndex];
-			const children: WorkflowGraphNode[] = [];
-			const childStatuses: WorkflowNodeStatus[] = [];
-			for (let taskIndex = 0; taskIndex < materialized.length; taskIndex++) {
-				const task = materialized[taskIndex]!;
-				const status = nodeStatus(input, task.flatIndex);
-				childStatuses.push(status);
-				const childId = `step-${stepIndex}-item-${task.itemKey.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
-				const child: WorkflowGraphNode = {
-					id: childId,
-					kind: "agent",
-					agent: task.agent,
-					phase: step.parallel.phase ?? step.phase,
-					label: task.label?.trim() || step.parallel.label?.trim() || `${task.agent} ${task.itemKey}`,
-					status,
-					flatIndex: task.flatIndex,
-					stepIndex,
-					itemKey: task.itemKey,
-					outputName: task.outputName,
-					structured: task.structured,
-					error:
-						input.stepStatuses?.[task.flatIndex]?.error ?? input.results?.[task.flatIndex]?.error ?? task.error,
-				};
-				children.push(child);
-				pushPhase(phases, child.phase, childId);
-				if (status === "running" || input.currentFlatIndex === task.flatIndex) currentNodeId = childId;
-			}
-			const groupStatus =
-				groupOverride?.status ??
-				(children.length > 0
-					? summarizeParallelStatuses(childStatuses)
-					: input.currentStepIndex === stepIndex
-						? "running"
-						: "pending");
-			if (input.currentStepIndex === stepIndex && !currentNodeId) currentNodeId = groupId;
-			nodes.push({
-				id: groupId,
-				kind: "dynamic-parallel-group",
-				label: step.label?.trim() || step.parallel.label?.trim() || `Dynamic fanout (${step.collect.as})`,
-				status: groupStatus,
-				stepIndex,
-				outputName: step.collect.as,
-				structured: Boolean(step.collect.outputSchema),
-				error: groupOverride?.error,
-				dynamic: {
-					sourceOutput: step.expand.from.output,
-					sourcePath: step.expand.from.path,
-					itemName: step.expand.item ?? "item",
-					maxItems: step.expand.maxItems,
-					collectAs: step.collect.as,
-				},
-				children,
-			});
-			if (materialized.length > 0)
-				flatIndex = Math.max(flatIndex, ...materialized.map((child) => child.flatIndex + 1));
-			continue;
-		}
-
-		const seq = step as SequentialStep;
-		const status = nodeStatus(input, flatIndex);
-		const id = `step-${stepIndex}`;
-		nodes.push({
-			id,
-			kind: "step",
-			agent: seq.agent,
-			phase: seq.phase,
-			label: seqLabel(seq, stepIndex),
-			status,
-			flatIndex,
-			stepIndex,
-			outputName: seq.as,
-			structured: Boolean(seq.outputSchema),
-			error: input.stepStatuses?.[flatIndex]?.error ?? input.results?.[flatIndex]?.error,
-		});
-		pushPhase(phases, seq.phase, id);
-		if (status === "running" || input.currentFlatIndex === flatIndex || input.currentStepIndex === stepIndex)
-			currentNodeId = id;
-		flatIndex++;
-	}
-
-	return {
-		runId: input.runId,
-		mode: input.mode ?? "chain",
-		phases,
-		nodes,
-		currentNodeId,
-	};
-}

package/dist/builtin/subagents/src/slash/saved-chain-mapping.ts

@@ -1,60 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import type { ChainConfig } from "../agents/agents.ts";
-import { type ChainStep, isDynamicParallelStep, isParallelStep } from "../shared/settings.ts";
-import type { JsonSchemaObject } from "../shared/types.ts";
-
-function loadSavedOutputSchema(
-	chain: ChainConfig,
-	_stepAgent: string,
-	outputSchema: unknown,
-): JsonSchemaObject | undefined {
-	if (outputSchema === undefined) return undefined;
-	if (typeof outputSchema === "string") {
-		const schemaPath = path.isAbsolute(outputSchema)
-			? outputSchema
-			: path.join(path.dirname(chain.filePath), outputSchema);
-		return JSON.parse(fs.readFileSync(schemaPath, "utf-8")) as JsonSchemaObject;
-	}
-	return outputSchema as JsonSchemaObject;
-}
-
-export function mapSavedChainSteps(chain: ChainConfig, worktree = false): ChainStep[] {
-	return (chain.steps as unknown as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
-		if (isParallelStep(step)) {
-			const parallel = step.parallel.map((task) => {
-				const { outputSchema: rawOutputSchema, ...rest } = task as typeof task & { outputSchema?: unknown };
-				const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-				return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
-			});
-			return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
-		}
-		if (isDynamicParallelStep(step)) {
-			const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel as typeof step.parallel & {
-				outputSchema?: unknown;
-			};
-			const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-			const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-			return {
-				...step,
-				parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
-				collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
-			};
-		}
-		const outputSchema = loadSavedOutputSchema(chain, step.agent, (step as { outputSchema?: unknown }).outputSchema);
-		return {
-			agent: step.agent,
-			task: step.task || undefined,
-			...(step.phase ? { phase: step.phase } : {}),
-			...(step.label ? { label: step.label } : {}),
-			...(step.as ? { as: step.as } : {}),
-			...(outputSchema ? { outputSchema } : {}),
-			output: step.output,
-			outputMode: step.outputMode,
-			reads: step.reads,
-			progress: step.progress,
-			skill: step.skill ?? step.skills,
-			model: step.model,
-		};
-	});
-}