@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/runs/background/async-execution-single.ts

@@ -1,279 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getEnvValue } from "@bastani/atomic";
-import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import {
-	getSubagentCodexFastModeSettings,
-	resolveSubagentCodexFastModeScope,
-	resolveSubagentModelFastModeMetadata,
-} from "../../shared/fast-mode.ts";
-import { resolveEffectiveThinking } from "../../shared/model-info.ts";
-import { injectSingleProgressInstruction, writeInitialProgressFile } from "../../shared/settings.ts";
-import {
-	ASYNC_DIR,
-	RESULTS_DIR,
-	resolveChildMaxSubagentDepth,
-	SUBAGENT_ASYNC_STARTED_EVENT,
-} from "../../shared/types.ts";
-import { workflowSessionEnv } from "../../shared/types-depth.ts";
-import { resolveChildCwd } from "../../shared/utils.ts";
-import { resolveChildIntercomGroup } from "../shared/intercom-group.ts";
-import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
-import { buildModelCandidates, resolveModelCandidate } from "../shared/model-fallback.ts";
-import {
-	NESTED_RUNS_DIR,
-	nestedResultsPath,
-	resolveInheritedNestedRouteFromEnv,
-	resolveNestedParentAddressFromEnv,
-	writeNestedEvent,
-} from "../shared/nested-events.ts";
-import { applyThinkingSuffix, SUBAGENT_INTERCOM_SESSION_NAME_ENV } from "../shared/pi-args.ts";
-import {
-	injectSingleOutputInstruction,
-	normalizeSingleOutputOverride,
-	resolveSingleOutputPath,
-	validateFileOnlyOutputMode,
-} from "../shared/single-output.ts";
-import {
-	spawnRunner as defaultSpawnRunner,
-	formatAsyncStartError,
-	formatAsyncStartedMessage,
-	piPackageRoot,
-	UNAVAILABLE_SUBAGENT_SKILL_ERROR,
-} from "./async-execution-common.ts";
-import type { AsyncExecutionResult, AsyncSingleParams, AsyncSpawnResult } from "./async-execution-types.ts";
-
-/**
- * Execute a single agent asynchronously
- */
-export function executeAsyncSingle(id: string, params: AsyncSingleParams): AsyncExecutionResult {
-	const {
-		agent,
-		agentConfig,
-		ctx,
-		cwd,
-		maxOutput,
-		artifactsDir,
-		artifactConfig,
-		shareEnabled,
-		sessionRoot,
-		sessionFile,
-		maxSubagentDepth,
-		workflowStageSubagentGuard,
-		worktreeSetupHook,
-		worktreeSetupHookTimeoutMs,
-		controlConfig,
-		controlIntercomTarget,
-		childIntercomTarget,
-		supervisorAuthorization,
-		nestedRoute,
-		spawnRunner = defaultSpawnRunner,
-	} = params;
-	const task = params.task ?? "";
-	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
-	const skillNames = params.skills ?? agentConfig.skills ?? [];
-	const availableModels = params.availableModels;
-	const knownModelProviders = params.knownModelProviders;
-	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(
-		skillNames,
-		runnerCwd,
-		ctx.cwd,
-	);
-	if (missingSkills.includes("subagent")) return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
-	let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
-	if (resolvedSkills.length > 0) {
-		const injection = buildSkillInjection(resolvedSkills);
-		systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
-	}
-
-	const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
-	const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
-	const asyncDir = inheritedNestedRoute
-		? path.join(NESTED_RUNS_DIR, inheritedNestedRoute.rootRunId, id)
-		: path.join(ASYNC_DIR, id);
-	try {
-		fs.mkdirSync(asyncDir, { recursive: true });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return {
-			content: [{ type: "text", text: `Failed to create async run directory '${asyncDir}': ${message}` }],
-			isError: true,
-			details: { mode: "single" as const, results: [] },
-		};
-	}
-
-	const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
-	const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd);
-	const outputMode = params.outputMode ?? "inline";
-	const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
-	if (validationError) return formatAsyncStartError("single", validationError);
-	let taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath);
-	// Keep each child's progress contract outside its cwd and isolated by run;
-	// artifacts-disabled async runs use their already run-owned async directory.
-	if (params.progress) {
-		const progressDir =
-			artifactConfig.enabled && artifactsDir
-				? path.join(artifactsDir, "progress", id)
-				: path.join(asyncDir, "progress");
-		writeInitialProgressFile(progressDir);
-		taskWithOutputInstruction = injectSingleProgressInstruction(taskWithOutputInstruction, progressDir);
-	}
-	const model = applyThinkingSuffix(
-		resolveModelCandidate(params.modelOverride ?? agentConfig.model, availableModels, ctx.currentModelProvider),
-		agentConfig.thinking,
-	);
-	const rawModelCandidates = buildModelCandidates(
-		params.modelOverride ?? agentConfig.model,
-		agentConfig.fallbackModels,
-		availableModels,
-		ctx.currentModelProvider,
-		ctx.currentModel,
-	)
-		.map((candidate) => applyThinkingSuffix(candidate, agentConfig.thinking))
-		.filter((candidate): candidate is string => typeof candidate === "string");
-	const filteredCandidates = filterSpawnableModelCandidates({
-		candidates: rawModelCandidates,
-		availableModels,
-		knownModelProviders,
-		currentModel: applyThinkingSuffix(ctx.currentModel, agentConfig.thinking),
-	});
-	const modelCandidates = filteredCandidates.candidates;
-	const fastModeSettings = getSubagentCodexFastModeSettings(runnerCwd);
-	const fastModeScope = resolveSubagentCodexFastModeScope(workflowStageSubagentGuard);
-	let spawnResult: AsyncSpawnResult = {};
-	try {
-		spawnResult = spawnRunner(
-			{
-				id,
-				steps: [
-					{
-						agent,
-						task: taskWithOutputInstruction,
-						intercomGroup: resolveChildIntercomGroup(params.group, ctx.intercomGroup, undefined),
-						cwd: runnerCwd,
-						model,
-						thinking: resolveEffectiveThinking(model, agentConfig.thinking),
-						...resolveSubagentModelFastModeMetadata({
-							model,
-							modelCandidates,
-							cwd: runnerCwd,
-							settings: fastModeSettings,
-							scope: fastModeScope,
-						}),
-						modelCandidates,
-						modelAttempts: filteredCandidates.skippedAttempts,
-						codexFastModeSettings: fastModeSettings,
-						codexFastModeScope: fastModeScope,
-						tools: agentConfig.tools,
-						extensions: agentConfig.extensions,
-						mcpDirectTools: agentConfig.mcpDirectTools,
-						systemPrompt,
-						systemPromptMode: agentConfig.systemPromptMode,
-						inheritProjectContext: agentConfig.inheritProjectContext,
-						inheritSkills: agentConfig.inheritSkills,
-						skills: resolvedSkills.map((r) => r.name),
-						outputPath,
-						outputMode,
-						sessionFile,
-						maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
-						workflowStageSubagentGuard,
-					},
-				],
-				resultPath: inheritedNestedRoute
-					? nestedResultsPath(inheritedNestedRoute.rootRunId, id)
-					: path.join(RESULTS_DIR, `${id}.json`),
-				cwd: runnerCwd,
-				placeholder: "{previous}",
-				maxOutput,
-				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-				artifactConfig,
-				share: shareEnabled,
-				sessionDir: sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined,
-				asyncDir,
-				sessionId: ctx.currentSessionId,
-				piPackageRoot,
-				piArgv1: process.argv[1],
-				worktreeSetupHook,
-				worktreeSetupHookTimeoutMs,
-				controlConfig,
-				controlIntercomTarget,
-				childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
-				supervisorAuthorizations: supervisorAuthorization ? [supervisorAuthorization] : undefined,
-				resultMode: "single",
-				nestedRoute: nestedRoute ?? inheritedNestedRoute,
-				workflowStageSubagentGuard,
-				nestedSelf:
-					inheritedNestedRoute && nestedAddress
-						? {
-								parentRunId: nestedAddress.parentRunId,
-								parentStepIndex: nestedAddress.parentStepIndex,
-								depth: nestedAddress.depth,
-								path: nestedAddress.path,
-							}
-						: undefined,
-			},
-			id,
-			runnerCwd,
-			workflowSessionEnv(ctx.workflowSessionMetadata),
-		);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return formatAsyncStartError("single", `Failed to start async run '${id}': ${message}`);
-	}
-
-	if (spawnResult.error) {
-		return formatAsyncStartError("single", `Failed to start async run '${id}': ${spawnResult.error}`);
-	}
-
-	if (spawnResult.pid) {
-		if (inheritedNestedRoute && nestedAddress) {
-			const now = Date.now();
-			try {
-				writeNestedEvent(inheritedNestedRoute, {
-					type: "subagent.nested.started",
-					ts: now,
-					parentRunId: nestedAddress.parentRunId,
-					parentStepIndex: nestedAddress.parentStepIndex,
-					child: {
-						id,
-						parentRunId: nestedAddress.parentRunId,
-						parentStepIndex: nestedAddress.parentStepIndex,
-						depth: nestedAddress.depth,
-						path: nestedAddress.path,
-						asyncDir,
-						pid: spawnResult.pid,
-						ownerIntercomTarget: getEnvValue(SUBAGENT_INTERCOM_SESSION_NAME_ENV),
-						leafIntercomTarget: childIntercomTarget?.(agent, 0),
-						intercomTarget: childIntercomTarget?.(agent, 0),
-						ownerState: "live",
-						mode: "single",
-						state: "running",
-						agent,
-						agents: [agent],
-						chainStepCount: 1,
-						startedAt: now,
-						lastUpdate: now,
-					},
-				});
-			} catch (error) {
-				console.error("Failed to emit nested async start event:", error);
-			}
-		}
-		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-			id,
-			pid: spawnResult.pid,
-			sessionId: ctx.currentSessionId,
-			mode: "single",
-			agent,
-			task: task?.slice(0, 50),
-			cwd: runnerCwd,
-			asyncDir,
-			nestedRoute,
-		});
-	}
-
-	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
-		details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir },
-	};
-}

package/dist/builtin/subagents/src/runs/background/async-execution-types.ts

@@ -1,99 +0,0 @@
-import type { ExtensionAPI, SessionWorkflowMetadata } from "@bastani/atomic";
-import type { AgentConfig } from "../../agents/agents.ts";
-import type { SupervisorAuthorization } from "../../intercom/supervisor-authorization.ts";
-import type { ChainStep } from "../../shared/settings.ts";
-import type {
-	ArtifactConfig,
-	Details,
-	MaxOutputConfig,
-	NestedRouteInfo,
-	ResolvedControlConfig,
-	SubagentRunMode,
-} from "../../shared/types.ts";
-import type { AvailableModelInfo } from "../shared/model-fallback.ts";
-
-export interface AsyncExecutionContext {
-	pi: ExtensionAPI;
-	cwd: string;
-	currentSessionId: string;
-	currentModelProvider?: string;
-	currentModel?: string;
-	intercomGroup?: string;
-	workflowSessionMetadata?: SessionWorkflowMetadata;
-}
-
-export interface AsyncChainParams {
-	chain: ChainStep[];
-	task?: string;
-	group?: string | true;
-	resultMode?: Exclude<SubagentRunMode, "single">;
-	agents: AgentConfig[];
-	ctx: AsyncExecutionContext;
-	availableModels?: AvailableModelInfo[];
-	knownModelProviders?: string[];
-	cwd?: string;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig: ArtifactConfig;
-	shareEnabled: boolean;
-	sessionRoot?: string;
-	chainSkills?: string[];
-	sessionFilesByFlatIndex?: (string | undefined)[];
-	dynamicFanoutMaxItems?: number;
-	maxSubagentDepth: number;
-	workflowStageSubagentGuard?: boolean;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	supervisorAuthorizations?: Array<SupervisorAuthorization | undefined>;
-	dynamicSupervisorAuthorizations?: Record<number, SupervisorAuthorization[]>;
-	/** Internal launch seam used by focused runtime tests. */
-	spawnRunner?: (config: object, suffix: string, cwd: string, env?: Record<string, string>) => AsyncSpawnResult;
-	nestedRoute?: NestedRouteInfo;
-}
-
-export interface AsyncSingleParams {
-	agent: string;
-	task?: string;
-	group?: string | true;
-	agentConfig: AgentConfig;
-	ctx: AsyncExecutionContext;
-	cwd?: string;
-	maxOutput?: MaxOutputConfig;
-	artifactsDir?: string;
-	artifactConfig: ArtifactConfig;
-	shareEnabled: boolean;
-	sessionRoot?: string;
-	sessionFile?: string;
-	skills?: string[];
-	output?: string | boolean;
-	outputMode?: "inline" | "file-only";
-	progress?: boolean;
-	modelOverride?: string;
-	availableModels?: AvailableModelInfo[];
-	knownModelProviders?: string[];
-	maxSubagentDepth: number;
-	workflowStageSubagentGuard?: boolean;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	supervisorAuthorization?: SupervisorAuthorization;
-	nestedRoute?: NestedRouteInfo;
-	/** Internal launch seam used by focused runtime tests. */
-	spawnRunner?: (config: object, suffix: string, cwd: string, env?: Record<string, string>) => AsyncSpawnResult;
-}
-
-export interface AsyncExecutionResult {
-	content: Array<{ type: "text"; text: string }>;
-	details: Details;
-	isError?: boolean;
-}
-
-export interface AsyncSpawnResult {
-	pid?: number;
-	error?: string;
-}

package/dist/builtin/subagents/src/runs/background/async-execution.ts

@@ -1,17 +0,0 @@
-/**
- * Async execution logic for subagent tool
- */
-
-export { executeAsyncChain } from "./async-execution-chain.ts";
-export {
-	formatAsyncStartedMessage,
-	isAsyncAvailable,
-	writeAsyncRunnerConfig,
-} from "./async-execution-common.ts";
-export { executeAsyncSingle } from "./async-execution-single.ts";
-export type {
-	AsyncChainParams,
-	AsyncExecutionContext,
-	AsyncExecutionResult,
-	AsyncSingleParams,
-} from "./async-execution-types.ts";