@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.3

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

@@ -1,139 +0,0 @@
-import type { AgentConfig } from "../../agents/agents.js";
-import type { Details, SubagentToolResult } from "../../shared/types.js";
-import type { SubagentParamsLike, TaskParam } from "./subagent-executor-types.js";
-
-export function validateExecutionInput(
-	params: SubagentParamsLike,
-	agents: AgentConfig[],
-	hasTasks: boolean,
-	hasSingle: boolean,
-	parallelAgentConfigs?: AgentConfig[],
-): SubagentToolResult | null {
-	if (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) {
-		const reads = params.reads;
-		if (
-			reads !== undefined &&
-			reads !== false &&
-			(!Array.isArray(reads) || reads.some((entry) => typeof entry !== "string"))
-		) {
-			return {
-				content: [{ type: "text", text: "reads must be an array of file path strings or false" }],
-				isError: true,
-				details: { mode: "single", 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]!;
-			const agent = parallelAgentConfigs?.[i] ?? agents.find((candidate) => candidate.name === task.agent);
-			if (!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: [] },
-				};
-			}
-		}
-	}
-
-	return null;
-}
-
-export function getRequestedModeLabel(params: SubagentParamsLike): Details["mode"] {
-	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);
-	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: _count, ...concreteTask } = task;
-		for (let repeat = 0; repeat < (rawCount ?? 1); repeat++) expanded.push({ ...concreteTask });
-	}
-	return { tasks: expanded };
-}
-
-export function normalizeRepeatedParallelCounts(params: SubagentParamsLike): {
-	params?: SubagentParamsLike;
-	error?: SubagentToolResult;
-} {
-	if (!params.tasks) return { params };
-	const expandedTasks = expandTopLevelTaskCounts(params.tasks);
-	if (expandedTasks.error) return { error: buildRequestedModeError(params, expandedTasks.error) };
-	return { params: { ...params, tasks: expandedTasks.tasks } };
-}
-
-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,
-	);
-}

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

@@ -1,11 +0,0 @@
-import type { SubagentToolResult } from "../../shared/types.js";
-
-const liveResultIndices = new WeakMap<SubagentToolResult, readonly number[]>();
-
-export function markLiveResultIndices(result: SubagentToolResult, indices: readonly number[]): void {
-	liveResultIndices.set(result, indices);
-}
-
-export function getLiveResultIndices(result: SubagentToolResult): readonly number[] | undefined {
-	return liveResultIndices.get(result);
-}

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

@@ -1,268 +0,0 @@
-import type { ExtensionContext } from "@bastani/atomic";
-import type { AgentConfig } from "../../agents/agents.js";
-import { INTERCOM_BRIDGE_MARKER } from "../../intercom/intercom-bridge.js";
-import { requestSupervisorAuthorization } from "../../intercom/supervisor-authorization.js";
-import type { ModelInfo } from "../../shared/model-info.js";
-import type { CandidateModelResolver } from "../../shared/model-resolution.js";
-import { buildTaskInstructions, type ResolvedStepBehavior } from "../../shared/settings.js";
-import type {
-	AgentProgress,
-	ArtifactConfig,
-	ControlEvent,
-	ForegroundParentAskHandoff,
-	IntercomEventBus,
-	MaxOutputConfig,
-	RunSyncOptions,
-	SingleResult,
-	SubagentState,
-	SubagentToolResult,
-} from "../../shared/types.js";
-import { workflowSessionMetadataFromContext } from "../../shared/types-depth.js";
-import { mapConcurrent } from "../../shared/utils.js";
-import { inheritedIntercomGroup, resolveChildIntercomGroup } from "../shared/intercom-group.js";
-import { currentModelFullId } from "../shared/model-fallback.js";
-import { injectSingleOutputInstruction, resolveSingleOutputPath } from "../shared/single-output.js";
-import type { WorktreeSetup } from "../shared/worktree.js";
-import { markLiveResultIndices } from "./subagent-executor-live-update.js";
-import type { SubagentExecutorRuntimeDeps, TaskParam } from "./subagent-executor-types.js";
-import { resolveParallelTaskCwd } from "./subagent-executor-worktree.js";
-
-interface ForegroundParallelRunInput {
-	tasks: TaskParam[];
-	taskTexts: string[];
-	agents: AgentConfig[];
-	agentConfigs?: 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;
-	parentDepth?: number;
-	workflowStageSubagentGuard?: boolean;
-	availableModels: ModelInfo[];
-	knownModelProviders: string[];
-	resolveCandidateModel: CandidateModelResolver;
-	modelOverrides: (string | undefined)[];
-	behaviors: ResolvedStepBehavior[];
-	firstProgressIndex: number;
-	controlConfig: import("../../shared/types.js").ResolvedControlConfig;
-	onControlEvent?: (event: ControlEvent) => void;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	orchestratorIntercomTarget?: string;
-	setIntercomGroup?: string | true;
-	sharedAutoIntercomGroup?: string;
-	foregroundControl?: SubagentState["foregroundControls"] extends Map<string, infer T> ? T : never;
-	concurrencyLimit: number;
-	liveResults: (SingleResult | undefined)[];
-	liveProgress: (AgentProgress | undefined)[];
-	onUpdate?: (r: SubagentToolResult) => void;
-	onParentAskHandoff?: (handoff: ForegroundParentAskHandoff) => void;
-	onDetachedExit?: (index: number, result: SingleResult) => void;
-	onExecution?: (index: number, runtimeCwd: string, options: RunSyncOptions) => void;
-	worktreeSetup?: WorktreeSetup;
-	runtime: Pick<SubagentExecutorRuntimeDeps, "runSync">;
-}
-
-function skippedParallelResult(task: TaskParam, taskText: string, error: string): SingleResult {
-	return {
-		agent: task.agent,
-		task: taskText,
-		status: "skipped",
-		messages: [],
-		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-		error,
-	};
-}
-
-export async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Promise<SingleResult[]> {
-	const intercomDetachController = new AbortController();
-	const parentAskController = new AbortController();
-	const startedIndices = new Set<number>();
-	const activeIndices = new Set<number>();
-	return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
-		if (parentAskController.signal.aborted) {
-			return skippedParallelResult(task, input.taskTexts[index] ?? task.task, "Skipped after parent ask handoff");
-		}
-		if (intercomDetachController.signal.aborted) {
-			return skippedParallelResult(
-				task,
-				input.taskTexts[index] ?? task.task,
-				"Skipped after foreground group detached for intercom coordination",
-			);
-		}
-		const behavior = input.behaviors[index];
-		const effectiveSkills = behavior?.skills;
-		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
-		const readInstructions = behavior
-			? buildTaskInstructions({ ...behavior, output: false, progress: false }, taskCwd, false)
-			: { prefix: "", suffix: "" };
-		const progressInstructions = behavior
-			? buildTaskInstructions(
-					{ ...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 childIntercomTarget = input.childIntercomTarget?.(task.agent, index);
-		const supervisorAuthorization = await requestSupervisorAuthorization(input.intercomEvents, childIntercomTarget);
-		if (parentAskController.signal.aborted) {
-			return skippedParallelResult(task, input.taskTexts[index] ?? task.task, "Skipped after parent ask handoff");
-		}
-		if (intercomDetachController.signal.aborted) {
-			return skippedParallelResult(
-				task,
-				input.taskTexts[index] ?? task.task,
-				"Skipped after foreground group detached for intercom coordination",
-			);
-		}
-		const interruptController = new AbortController();
-		const interruptForParentAsk = () => interruptController.abort();
-		parentAskController.signal.addEventListener("abort", interruptForParentAsk, { once: true });
-		if (parentAskController.signal.aborted) interruptController.abort();
-		startedIndices.add(index);
-		activeIndices.add(index);
-		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.agentConfigs?.[index] ?? input.agents.find((agent) => agent.name === task.agent);
-		const taskAgents = input.agentConfigs && agentConfig ? [agentConfig] : input.agents;
-		const runOptions: RunSyncOptions = {
-			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,
-			parentDepth: input.parentDepth,
-			workflowStageSubagentGuard: input.workflowStageSubagentGuard,
-			workflowSessionMetadata: workflowSessionMetadataFromContext(input.ctx),
-			controlConfig: input.controlConfig,
-			onControlEvent: input.onControlEvent,
-			intercomSessionName: childIntercomTarget,
-			supervisorAuthorization,
-			orchestratorIntercomTarget: input.orchestratorIntercomTarget,
-			intercomGroup: resolveChildIntercomGroup(
-				task.group ?? input.setIntercomGroup,
-				inheritedIntercomGroup(input.ctx),
-				input.sharedAutoIntercomGroup,
-			),
-			onDetachedExit: (result) => input.onDetachedExit?.(index, result),
-			intercomDetachSignal: intercomDetachController.signal,
-			onIntercomDetachCommit: () => intercomDetachController.abort(),
-			onParentAskHandoff: input.onParentAskHandoff
-				? (request) => {
-						if (parentAskController.signal.aborted) return;
-						request.taskContext = input.tasks[request.index]?.task ?? "";
-						input.onParentAskHandoff?.({
-							askingChildIndex: request.index,
-							releasedChildIndices: [...activeIndices].sort((left, right) => left - right),
-							unlaunchedChildIndices: input.tasks
-								.map((_, taskIndex) => taskIndex)
-								.filter((taskIndex) => !startedIndices.has(taskIndex)),
-							request,
-						});
-						parentAskController.abort();
-					}
-				: undefined,
-			modelOverride: input.modelOverrides[index],
-			availableModels: input.availableModels,
-			knownModelProviders: input.knownModelProviders,
-			resolveCandidateModel: input.resolveCandidateModel,
-			preferredModelProvider: input.ctx.model?.provider,
-			currentModel: currentModelFullId(input.ctx.model),
-			currentThinkingLevel: input.ctx.thinkingLevel,
-			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 indexedResults = input.liveResults.flatMap((result, resultIndex) =>
-							result === undefined ? [] : [{ result, index: resultIndex }],
-						);
-						const mergedResults = indexedResults.map(({ result }) => result);
-						const mergedProgress = input.liveProgress.filter(
-							(progress): progress is AgentProgress => progress !== undefined,
-						);
-						const controlEvents = progressUpdate.details?.controlEvents?.map((event) => ({ ...event, index }));
-						const artifactDir = progressUpdate.details?.artifacts?.dir;
-						const artifactFiles = mergedResults.flatMap((result) =>
-							result.artifactPaths ? [result.artifactPaths] : [],
-						);
-						const aggregateUpdate: SubagentToolResult = {
-							content: progressUpdate.content,
-							details: {
-								mode: "parallel",
-								results: mergedResults,
-								progress: mergedProgress,
-								...(controlEvents?.length ? { controlEvents } : {}),
-								totalSteps: input.tasks.length,
-								...(artifactDir && artifactFiles.length
-									? { artifacts: { dir: artifactDir, files: artifactFiles } }
-									: {}),
-							},
-						};
-						markLiveResultIndices(
-							aggregateUpdate,
-							indexedResults.map(({ index: resultIndex }) => resultIndex),
-						);
-						input.onUpdate?.(aggregateUpdate);
-					}
-				: undefined,
-		};
-		input.onExecution?.(index, input.ctx.cwd, runOptions);
-		return input.runtime.runSync(input.ctx.cwd, taskAgents, task.agent, taskText, runOptions).finally(() => {
-			activeIndices.delete(index);
-			parentAskController.signal.removeEventListener("abort", interruptForParentAsk);
-			if (input.foregroundControl?.currentIndex === index) {
-				input.foregroundControl.interrupt = undefined;
-				input.foregroundControl.updatedAt = Date.now();
-			}
-		});
-	});
-}