@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-input.ts

@@ -0,0 +1,270 @@
+import { getStepAgents, isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
+import { wrapForkTask, type Details, type SubagentToolResult } from "../../shared/types.ts";
+import type { AgentConfig } from "../../agents/agents.ts";
+import type { SubagentParamsLike, TaskParam } from "./subagent-executor-types.ts";
+
+export function validateExecutionInput(
+	params: SubagentParamsLike,
+	agents: AgentConfig[],
+	hasChain: boolean,
+	hasTasks: boolean,
+	hasSingle: boolean,
+	allowClarifyTaskPrompt: boolean,
+): SubagentToolResult | null {
+	if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
+		return {
+			content: [
+				{
+					type: "text",
+					text: `Provide exactly one mode. Agents: ${agents.map((a) => a.name).join(", ") || "none"}`,
+				},
+			],
+			isError: true,
+			details: { mode: "single" as const, results: [] },
+		};
+	}
+
+	if (hasSingle && params.agent && !agents.find((agent) => agent.name === params.agent)) {
+		return {
+			content: [{ type: "text", text: `Unknown agent: ${params.agent}` }],
+			isError: true,
+			details: { mode: "single" as const, results: [] },
+		};
+	}
+
+	if (hasTasks && params.tasks) {
+		for (let i = 0; i < params.tasks.length; i++) {
+			const task = params.tasks[i]!;
+			if (!agents.find((agent) => agent.name === task.agent)) {
+				return {
+					content: [{ type: "text", text: `Unknown agent: ${task.agent} (task ${i + 1})` }],
+					isError: true,
+					details: { mode: "parallel" as const, results: [] },
+				};
+			}
+		}
+	}
+
+	if (hasChain && params.chain) {
+		if (params.chain.length === 0) {
+			return {
+				content: [{ type: "text", text: "Chain must have at least one step" }],
+				isError: true,
+				details: { mode: "chain" as const, results: [] },
+			};
+		}
+		const firstStep = params.chain[0] as ChainStep;
+		if (isParallelStep(firstStep)) {
+			const missingTaskIndex = firstStep.parallel.findIndex((t) => !t.task);
+			if (missingTaskIndex !== -1) {
+				return {
+					content: [{ type: "text", text: `First parallel step: task ${missingTaskIndex + 1} must have a task (no previous output to reference)` }],
+					isError: true,
+					details: { mode: "chain" as const, results: [] },
+				};
+			}
+		} else if (isDynamicParallelStep(firstStep)) {
+			return {
+				content: [{ type: "text", text: "First step in chain cannot be dynamic fanout; expand.from requires a prior structured named output" }],
+				isError: true,
+				details: { mode: "chain" as const, results: [] },
+			};
+		} else if (!(firstStep as SequentialStep).task && !params.task && !allowClarifyTaskPrompt) {
+			return {
+				content: [{ type: "text", text: "First step in chain must have a task" }],
+				isError: true,
+				details: { mode: "chain" as const, results: [] },
+			};
+		}
+		for (let i = 0; i < params.chain.length; i++) {
+			const step = params.chain[i] as ChainStep;
+			const stepAgents = getStepAgents(step);
+			for (const agentName of stepAgents) {
+				if (!agents.find((a) => a.name === agentName)) {
+					return {
+						content: [{ type: "text", text: `Unknown agent: ${agentName} (step ${i + 1})` }],
+						isError: true,
+						details: { mode: "chain" as const, results: [] },
+					};
+				}
+			}
+			if (isParallelStep(step) && step.parallel.length === 0) {
+				return {
+					content: [{ type: "text", text: `Parallel step ${i + 1} must have at least one task` }],
+					isError: true,
+					details: { mode: "chain" as const, results: [] },
+				};
+			}
+		}
+	}
+
+	return null;
+}
+
+export function getRequestedModeLabel(params: SubagentParamsLike): Details["mode"] {
+	if ((params.chain?.length ?? 0) > 0) return "chain";
+	if ((params.tasks?.length ?? 0) > 0) return "parallel";
+	if (params.agent) return "single";
+	return "single";
+}
+
+export function applyAgentDefaultContext(params: SubagentParamsLike, agents: AgentConfig[]): SubagentParamsLike {
+	if (params.context !== undefined) return params;
+	const byName = new Map(agents.map((agent) => [agent.name, agent]));
+	const names: string[] = [];
+	if (params.agent) names.push(params.agent);
+	for (const task of params.tasks ?? []) names.push(task.agent);
+	for (const step of params.chain ?? []) names.push(...getStepAgents(step));
+	return names.some((name) => byName.get(name)?.defaultContext === "fork")
+		? { ...params, context: "fork" }
+		: params;
+}
+
+function buildRequestedModeError(params: SubagentParamsLike, message: string): SubagentToolResult {
+	return withForkContext(
+		{
+			content: [{ type: "text", text: message }],
+			isError: true,
+			details: { mode: getRequestedModeLabel(params), results: [] },
+		},
+		params.context,
+	);
+}
+
+function expandTopLevelTaskCounts(tasks: TaskParam[]): { tasks?: TaskParam[]; error?: string } {
+	const expanded: TaskParam[] = [];
+	for (let taskIndex = 0; taskIndex < tasks.length; taskIndex++) {
+		const task = tasks[taskIndex]!;
+		const rawCount = (task as TaskParam & { count?: unknown }).count;
+		if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
+			return { error: `tasks[${taskIndex}].count must be an integer >= 1` };
+		}
+		const { count, ...concreteTask } = task;
+		for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) {
+			expanded.push({ ...concreteTask });
+		}
+	}
+	return { tasks: expanded };
+}
+
+function expandChainParallelCounts(chain: ChainStep[]): { chain?: ChainStep[]; error?: string } {
+	const expandedChain: ChainStep[] = [];
+	for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
+		const step = chain[stepIndex]!;
+		if (!isParallelStep(step)) {
+			expandedChain.push(step);
+			continue;
+		}
+		const expandedParallel = [];
+		for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
+			const task = step.parallel[taskIndex]!;
+			const rawCount = (task as typeof task & { count?: unknown }).count;
+			if (rawCount !== undefined && (typeof rawCount !== "number" || !Number.isInteger(rawCount) || rawCount < 1)) {
+				return { error: `chain[${stepIndex}].parallel[${taskIndex}].count must be an integer >= 1` };
+			}
+			const { count, ...concreteTask } = task;
+			for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) {
+				expandedParallel.push({ ...concreteTask });
+			}
+		}
+		expandedChain.push({ ...step, parallel: expandedParallel });
+	}
+	return { chain: expandedChain };
+}
+
+export function normalizeRepeatedParallelCounts(params: SubagentParamsLike): { params?: SubagentParamsLike; error?: SubagentToolResult } {
+	if (params.tasks) {
+		const expandedTasks = expandTopLevelTaskCounts(params.tasks);
+		if (expandedTasks.error) {
+			return { error: buildRequestedModeError(params, expandedTasks.error) };
+		}
+		return { params: { ...params, tasks: expandedTasks.tasks } };
+	}
+	if (params.chain) {
+		const expandedChain = expandChainParallelCounts(params.chain);
+		if (expandedChain.error) {
+			return { error: buildRequestedModeError(params, expandedChain.error) };
+		}
+		return { params: { ...params, chain: expandedChain.chain } };
+	}
+	return { params };
+}
+
+export function withForkContext(
+	result: SubagentToolResult,
+	context: SubagentParamsLike["context"],
+): SubagentToolResult {
+	if (context !== "fork" || !result.details) return result;
+	return {
+		...result,
+		details: {
+			...result.details,
+			context: "fork",
+		},
+	};
+}
+
+export function toExecutionErrorResult(params: SubagentParamsLike, error: unknown): SubagentToolResult {
+	const message = error instanceof Error ? error.message : String(error);
+	return withForkContext(
+		{
+			content: [{ type: "text", text: message }],
+			isError: true,
+			details: { mode: getRequestedModeLabel(params), results: [] },
+		},
+		params.context,
+	);
+}
+
+export function collectChainSessionFiles(
+	chain: ChainStep[],
+	sessionFileForIndex: (idx?: number) => string | undefined,
+): (string | undefined)[] {
+	const sessionFiles: (string | undefined)[] = [];
+	let flatIndex = 0;
+	for (const step of chain) {
+		if (isParallelStep(step)) {
+			for (let i = 0; i < step.parallel.length; i++) {
+				sessionFiles.push(sessionFileForIndex(flatIndex));
+				flatIndex++;
+			}
+			continue;
+		}
+		if (isDynamicParallelStep(step)) {
+			sessionFiles.push(undefined);
+			continue;
+		}
+		sessionFiles.push(sessionFileForIndex(flatIndex));
+		flatIndex++;
+	}
+	return sessionFiles;
+}
+
+export function wrapChainTasksForFork(chain: ChainStep[], context: SubagentParamsLike["context"]): ChainStep[] {
+	if (context !== "fork") return chain;
+	return chain.map((step, stepIndex) => {
+		if (isParallelStep(step)) {
+			return {
+				...step,
+				parallel: step.parallel.map((task) => ({
+					...task,
+					task: wrapForkTask(task.task ?? "{previous}"),
+				})),
+			};
+		}
+		if (isDynamicParallelStep(step)) {
+			return {
+				...step,
+				parallel: {
+					...step.parallel,
+					task: wrapForkTask(step.parallel.task ?? "{previous}"),
+				},
+			};
+		}
+		const sequential = step as SequentialStep;
+		return {
+			...sequential,
+			task: wrapForkTask(sequential.task ?? (stepIndex === 0 ? "{task}" : "{previous}")),
+		};
+	});
+}

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-parallel-task.ts

@@ -0,0 +1,157 @@
+import { currentModelFullId } from "../shared/model-fallback.ts";
+import { buildChainInstructions, type ResolvedStepBehavior } from "../../shared/settings.ts";
+import { injectSingleOutputInstruction, resolveSingleOutputPath } from "../shared/single-output.ts";
+import { mapConcurrent } from "../../shared/utils.ts";
+import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.ts";
+import type { AgentConfig } from "../../agents/agents.ts";
+import type { ModelInfo } from "../../shared/model-info.ts";
+import type { WorktreeSetup } from "../shared/worktree.ts";
+import {
+	type AgentProgress,
+	type ArtifactConfig,
+	type ControlEvent,
+	type IntercomEventBus,
+	type MaxOutputConfig,
+	type SingleResult,
+	type SubagentState,
+	type SubagentToolResult,
+} from "../../shared/types.ts";
+import type { ExtensionContext } from "@bastani/atomic";
+import type { SubagentExecutorRuntimeDeps, TaskParam } from "./subagent-executor-types.ts";
+import { resolveParallelTaskCwd } from "./subagent-executor-worktree.ts";
+
+interface ForegroundParallelRunInput {
+	tasks: TaskParam[];
+	taskTexts: string[];
+	agents: AgentConfig[];
+	ctx: ExtensionContext;
+	intercomEvents: IntercomEventBus;
+	signal: AbortSignal;
+	runId: string;
+	sessionDirForIndex: (idx?: number) => string | undefined;
+	sessionFileForIndex: (idx?: number) => string | undefined;
+	shareEnabled: boolean;
+	artifactConfig: ArtifactConfig;
+	artifactsDir: string;
+	maxOutput?: MaxOutputConfig;
+	paramsCwd: string;
+	maxSubagentDepths: number[];
+	workflowStageSubagentGuard?: boolean;
+	availableModels: ModelInfo[];
+	modelOverrides: (string | undefined)[];
+	behaviors: ResolvedStepBehavior[];
+	firstProgressIndex: number;
+	controlConfig: import("../../shared/types.ts").ResolvedControlConfig;
+	onControlEvent?: (event: ControlEvent) => void;
+	childIntercomTarget?: (agent: string, index: number) => string | undefined;
+	orchestratorIntercomTarget?: string;
+	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
+	concurrencyLimit: number;
+	liveResults: (SingleResult | undefined)[];
+	liveProgress: (AgentProgress | undefined)[];
+	onUpdate?: (r: SubagentToolResult) => void;
+	worktreeSetup?: WorktreeSetup;
+	runtime: Pick<SubagentExecutorRuntimeDeps, "runSync">;
+}
+
+export async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Promise<SingleResult[]> {
+	return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
+		const behavior = input.behaviors[index];
+		const effectiveSkills = behavior?.skills;
+		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
+		const readInstructions = behavior
+			? buildChainInstructions({ ...behavior, output: false, progress: false }, taskCwd, false)
+			: { prefix: "", suffix: "" };
+		const progressInstructions = behavior
+			? buildChainInstructions({ ...behavior, output: false, reads: false }, input.paramsCwd, index === input.firstProgressIndex)
+			: { prefix: "", suffix: "" };
+		const outputPath = resolveSingleOutputPath(behavior?.output, input.ctx.cwd, taskCwd);
+		const taskText = injectSingleOutputInstruction(
+			`${readInstructions.prefix}${input.taskTexts[index]!}${progressInstructions.suffix}`,
+			outputPath,
+		);
+		const interruptController = new AbortController();
+		if (input.foregroundControl) {
+			input.foregroundControl.currentAgent = task.agent;
+			input.foregroundControl.currentIndex = index;
+			input.foregroundControl.currentActivityState = undefined;
+			input.foregroundControl.updatedAt = Date.now();
+			input.foregroundControl.interrupt = () => {
+				if (interruptController.signal.aborted) return false;
+				interruptController.abort();
+				input.foregroundControl!.currentActivityState = undefined;
+				input.foregroundControl!.updatedAt = Date.now();
+				return true;
+			};
+		}
+		const agentConfig = input.agents.find((agent) => agent.name === task.agent);
+		return input.runtime.runSync(input.ctx.cwd, input.agents, task.agent, taskText, {
+			cwd: taskCwd,
+			signal: input.signal,
+			interruptSignal: interruptController.signal,
+			allowIntercomDetach: agentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: input.intercomEvents,
+			runId: input.runId,
+			index,
+			sessionDir: input.sessionDirForIndex(index),
+			sessionFile: input.sessionFileForIndex(index),
+			share: input.shareEnabled,
+			artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
+			artifactConfig: input.artifactConfig,
+			maxOutput: input.maxOutput,
+			outputPath,
+			outputMode: behavior?.outputMode,
+			maxSubagentDepth: input.maxSubagentDepths[index],
+			workflowStageSubagentGuard: input.workflowStageSubagentGuard,
+			controlConfig: input.controlConfig,
+			onControlEvent: input.onControlEvent,
+			intercomSessionName: input.childIntercomTarget?.(task.agent, index),
+			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
+			nestedRoute: input.foregroundControl?.nestedRoute,
+			modelOverride: input.modelOverrides[index],
+			availableModels: input.availableModels,
+			preferredModelProvider: input.ctx.model?.provider,
+			currentModel: currentModelFullId(input.ctx.model),
+			skills: effectiveSkills === false ? [] : effectiveSkills,
+			onUpdate: input.onUpdate
+				? (progressUpdate) => {
+					const stepResults = progressUpdate.details?.results || [];
+					const stepProgress = progressUpdate.details?.progress || [];
+					if (input.foregroundControl && stepProgress.length > 0) {
+						const current = stepProgress[0];
+						input.foregroundControl.currentAgent = task.agent;
+						input.foregroundControl.currentIndex = index;
+						input.foregroundControl.currentActivityState = current?.activityState;
+						input.foregroundControl.lastActivityAt = current?.lastActivityAt;
+						input.foregroundControl.currentTool = current?.currentTool;
+						input.foregroundControl.currentToolStartedAt = current?.currentToolStartedAt;
+						input.foregroundControl.currentPath = current?.currentPath;
+						input.foregroundControl.turnCount = current?.turnCount;
+						input.foregroundControl.tokens = current?.tokens;
+						input.foregroundControl.toolCount = current?.toolCount;
+						input.foregroundControl.updatedAt = Date.now();
+					}
+					if (stepResults.length > 0) input.liveResults[index] = stepResults[0];
+					if (stepProgress.length > 0) input.liveProgress[index] = stepProgress[0];
+					const mergedResults = input.liveResults.filter((result): result is SingleResult => result !== undefined);
+					const mergedProgress = input.liveProgress.filter((progress): progress is AgentProgress => progress !== undefined);
+					input.onUpdate?.({
+						content: progressUpdate.content,
+						details: {
+							mode: "parallel",
+							results: mergedResults,
+							progress: mergedProgress,
+							controlEvents: progressUpdate.details?.controlEvents,
+							totalSteps: input.tasks.length,
+						},
+					});
+				}
+				: undefined,
+		}).finally(() => {
+			if (input.foregroundControl?.currentIndex === index) {
+				input.foregroundControl.interrupt = undefined;
+				input.foregroundControl.updatedAt = Date.now();
+			}
+		});
+	});
+}