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

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

@@ -1,179 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { buildSkillInjection, resolveSkillsWithFallback } from "../../agents/skills.ts";
-import { injectSingleProgressInstruction, writeInitialProgressFile } from "../../shared/settings.ts";
-import {
-	ASYNC_DIR,
-	resolveChildMaxSubagentDepth,
-	SUBAGENT_ASYNC_COMPLETE_EVENT,
-	SUBAGENT_ASYNC_STARTED_EVENT,
-} from "../../shared/types.ts";
-import { resolveChildCwd } from "../../shared/utils.ts";
-import { runSingleInProcess } from "../foreground/inprocess-run-sync.ts";
-import { resolveChildIntercomGroup } from "../shared/intercom-group.ts";
-import { filterSpawnableModelCandidates } from "../shared/model-candidate-filter.ts";
-import { buildModelCandidates } from "../shared/model-fallback.ts";
-import {
-	injectSingleOutputInstruction,
-	normalizeSingleOutputOverride,
-	resolveSingleOutputPath,
-	validateFileOnlyOutputMode,
-} from "../shared/single-output.ts";
-import {
-	type AsyncExecutionResult,
-	type AsyncSingleParams,
-	formatAsyncStartError,
-	formatAsyncStartedMessage,
-	UNAVAILABLE_SUBAGENT_SKILL_ERROR,
-} from "./background.ts";
-
-/**
- * Execute a single agent asynchronously using the in-process runner.
- *
- * The returned promise resolves after admission and continuation, not after the
- * model attempt. Terminal delivery happens through the existing detached-exit
- * callback and in-memory result path.
- */
-export async function executeAsyncSingle(id: string, params: AsyncSingleParams): Promise<AsyncExecutionResult> {
-	const {
-		agent,
-		agentConfig,
-		ctx,
-		cwd,
-		maxOutput,
-		artifactsDir,
-		artifactConfig,
-		sessionRoot,
-		sessionFile,
-		maxSubagentDepth,
-		workflowStageSubagentGuard,
-		controlConfig,
-		controlIntercomTarget,
-		childIntercomTarget,
-	} = params;
-	const task = params.task ?? "";
-	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
-	const skillNames = params.skills ?? agentConfig.skills ?? [];
-	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 asyncDir = path.join(ASYNC_DIR, id);
-	try {
-		fs.mkdirSync(asyncDir, { recursive: true });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		return formatAsyncStartError("single", `Failed to create async run directory '${asyncDir}': ${message}`);
-	}
-
-	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);
-	if (params.progress) {
-		const progressDir =
-			artifactConfig.enabled && artifactsDir
-				? path.join(artifactsDir, "progress", id)
-				: path.join(asyncDir, "progress");
-		writeInitialProgressFile(progressDir);
-		taskWithOutputInstruction = injectSingleProgressInstruction(taskWithOutputInstruction, progressDir);
-	}
-
-	const availableModels = params.availableModels;
-	const knownModelProviders = params.knownModelProviders;
-	const rawModelCandidates = buildModelCandidates(
-		params.modelOverride ?? agentConfig.model,
-		agentConfig.fallbackModels,
-		availableModels,
-		ctx.currentModelProvider,
-		ctx.currentModel,
-		agentConfig.fallbackThinkingLevels,
-	);
-	const filteredCandidates = filterSpawnableModelCandidates({
-		candidates: rawModelCandidates,
-		availableModels,
-		knownModelProviders,
-		currentModel: ctx.currentModel,
-	});
-	if (rawModelCandidates.length > 0 && filteredCandidates.candidates.length === 0) {
-		return formatAsyncStartError("single", "No spawnable subagent model candidates after pre-spawn filtering.");
-	}
-
-	const childAgent = { ...agentConfig, systemPrompt };
-	const result = await runSingleInProcess(runnerCwd, childAgent, taskWithOutputInstruction, {
-		cwd: runnerCwd,
-		runId: id,
-		sessionDir: path.join(sessionRoot ?? asyncDir, "session"),
-		sessionFile,
-		artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
-		artifactConfig,
-		maxOutput,
-		outputPath,
-		outputMode,
-		backgroundContinuation: true,
-		maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
-		workflowStageSubagentGuard,
-		workflowSessionMetadata: ctx.workflowSessionMetadata,
-		controlConfig,
-		supervisorAuthorization: params.supervisorAuthorization,
-		intercomSessionName: childIntercomTarget?.(agent, 0),
-		orchestratorIntercomTarget: controlIntercomTarget,
-		intercomGroup: resolveChildIntercomGroup(params.group, ctx.intercomGroup, undefined),
-		modelOverride: filteredCandidates.candidates[0] ?? params.modelOverride ?? agentConfig.model,
-		availableModels,
-		knownModelProviders,
-		preferredModelProvider: ctx.currentModelProvider,
-		currentModel: ctx.currentModel,
-		skills: resolvedSkills.map((skill) => skill.name),
-		testSession: params.testSession,
-		onDetachedExit: (completed) => {
-			const envelope = completed.envelope?.trim() ? completed.envelope : "(no output)";
-			ctx.pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
-				id,
-				runId: id,
-				asyncDir,
-				agent,
-				status: completed.status,
-				summary: envelope,
-				envelope,
-				timestamp: Date.now(),
-				sessionFile: completed.sessionFile,
-				results: [
-					{
-						agent,
-						output: envelope,
-						status: completed.status,
-						index: 0,
-						intercomTarget: childIntercomTarget?.(agent, 0),
-					},
-				],
-				result: completed,
-			});
-		},
-	});
-
-	ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-		id,
-		asyncDir,
-		sessionId: result.path,
-		mode: "single",
-		agent,
-		agents: [agent],
-	});
-	return {
-		content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
-		details: { mode: "single", runId: id, results: [result], asyncId: id, asyncDir },
-		...(result.status === "error" ? { isError: true } : {}),
-	};
-}

package/dist/builtin/subagents/src/runs/inprocess/background.ts

@@ -1,89 +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 { ModelInfo } from "../../shared/model-info.ts";
-import type { RunSyncOptions } from "../../shared/types.ts";
-
-export interface AsyncExecutionContext {
-	pi: ExtensionAPI;
-	cwd: string;
-	currentSessionId: string;
-	currentModelProvider?: string;
-	currentModel?: string;
-	intercomGroup?: string;
-	workflowSessionMetadata?: SessionWorkflowMetadata;
-}
-
-export interface AsyncSingleParams {
-	agent: string;
-	task?: string;
-	group?: string | true;
-	agentConfig: AgentConfig;
-	ctx: AsyncExecutionContext;
-	cwd?: string;
-	maxOutput?: { bytes?: number; lines?: number };
-	artifactsDir?: string;
-	artifactConfig: {
-		enabled: boolean;
-		includeInput: boolean;
-		includeOutput: boolean;
-		includeJsonl: boolean;
-		includeMetadata: boolean;
-		cleanupDays: number;
-	};
-	shareEnabled: boolean;
-	sessionRoot?: string;
-	sessionFile?: string;
-	skills?: string[];
-	output?: string | boolean;
-	outputMode?: "inline" | "file-only";
-	progress?: boolean;
-	modelOverride?: string;
-	availableModels?: ModelInfo[];
-	knownModelProviders?: string[];
-	maxSubagentDepth: number;
-	workflowStageSubagentGuard?: boolean;
-	worktreeSetupHook?: string;
-	worktreeSetupHookTimeoutMs?: number;
-	controlConfig?: import("../../shared/types.ts").ResolvedControlConfig;
-	controlIntercomTarget?: string;
-	childIntercomTarget?: (agent: string, index: number) => string | undefined;
-	supervisorAuthorization?: SupervisorAuthorization;
-	nestedRoute?: import("../../shared/types.ts").NestedRouteInfo;
-	/** Internal seam used by focused runtime tests. */
-	testSession?: RunSyncOptions["testSession"];
-}
-
-export interface AsyncExecutionResult {
-	content: Array<{ type: "text"; text: string }>;
-	details: import("../../shared/types.ts").Details;
-	isError?: boolean;
-}
-
-export function formatAsyncStartedMessage(headline: string): string {
-	return [
-		`Launched: ${headline}`,
-		"Completion pending; Atomic will deliver the result when the in-process child finishes.",
-		"",
-		"The async child is tied to the current parent process and does not survive parent exit.",
-		'Use subagent({ action: "status", id: "..." }) when you need the current status/result.',
-	].join("\n");
-}
-
-/** Async execution is always available because it no longer depends on a jiti child process. */
-export function isAsyncAvailable(): boolean {
-	return true;
-}
-
-export function formatAsyncStartError(mode: "single" | "parallel" | "chain", message: string): AsyncExecutionResult {
-	return {
-		content: [{ type: "text", text: message }],
-		isError: true,
-		details: { mode, results: [] },
-	};
-}
-
-export const UNAVAILABLE_SUBAGENT_SKILL_ERROR = "Skills not found: subagent";
-
-export class UnavailableSubagentSkillError extends Error {}
-export class AsyncStartValidationError extends Error {}

package/dist/builtin/subagents/src/runs/shared/chain-outputs.ts

@@ -1,126 +0,0 @@
-import { type ChainStep, isDynamicParallelStep, isParallelStep, type SequentialStep } from "../../shared/settings.ts";
-import type { ChainOutputMap, ChainOutputMapEntry, SingleResult } from "../../shared/types.ts";
-import { getSingleResultOutput } from "../../shared/utils.ts";
-import {
-	type DynamicFanoutConfig,
-	DynamicFanoutError,
-	hasDynamicFanoutFields,
-	validateDynamicStepShape,
-} from "./dynamic-fanout.ts";
-
-const OUTPUT_REF_PATTERN = /\{outputs\.([^}]*)\}/g;
-const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-export class ChainOutputValidationError extends Error {}
-
-function outputNamesForStep(step: ChainStep): string[] {
-	if (isParallelStep(step))
-		return step.parallel.map((task) => task.as).filter((name): name is string => Boolean(name));
-	if (isDynamicParallelStep(step)) return [step.collect.as];
-	const name = (step as SequentialStep).as;
-	return name ? [name] : [];
-}
-
-function taskTemplatesForStep(step: ChainStep): string[] {
-	if (isParallelStep(step)) return step.parallel.map((task) => task.task ?? "{previous}");
-	if (isDynamicParallelStep(step))
-		return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
-	return [(step as SequentialStep).task ?? "{previous}"];
-}
-
-export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutConfig: DynamicFanoutConfig = {}): void {
-	const available = new Set<string>();
-	const seen = new Set<string>();
-	for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
-		const step = steps[stepIndex]!;
-		if (hasDynamicFanoutFields(step)) {
-			if (!isDynamicParallelStep(step)) {
-				throw new ChainOutputValidationError(
-					`Dynamic chain step ${stepIndex + 1} requires expand, a single parallel template object, and collect; dynamic expand/collect cannot be mixed with static parallel arrays.`,
-				);
-			}
-			try {
-				validateDynamicStepShape(step, stepIndex, dynamicFanoutConfig);
-			} catch (error) {
-				if (error instanceof DynamicFanoutError) throw new ChainOutputValidationError(error.message);
-				throw error;
-			}
-			if (!available.has(step.expand.from.output)) {
-				throw new ChainOutputValidationError(
-					`Dynamic chain step ${stepIndex + 1} references unknown output '${step.expand.from.output}'. Named outputs are only available after producing step/group completes.`,
-				);
-			}
-		}
-		for (const name of outputNamesForStep(step)) {
-			if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-				throw new ChainOutputValidationError(
-					`Invalid chain output name '${name}' at step ${stepIndex + 1}. Use /^[A-Za-z_][A-Za-z0-9_]*$/.`,
-				);
-			}
-			if (seen.has(name)) {
-				throw new ChainOutputValidationError(`Duplicate chain output name '${name}'. Each as name must be unique.`);
-			}
-			seen.add(name);
-		}
-		for (const template of taskTemplatesForStep(step)) {
-			for (const match of template.matchAll(OUTPUT_REF_PATTERN)) {
-				const rawReference = match[0];
-				const name = match[1]!;
-				if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-					throw new ChainOutputValidationError(
-						`Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
-					);
-				}
-				if (!available.has(name)) {
-					throw new ChainOutputValidationError(
-						`Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`,
-					);
-				}
-			}
-		}
-		for (const name of outputNamesForStep(step)) {
-			available.add(name);
-		}
-	}
-}
-
-export function resolveOutputReferences(template: string, outputs: ChainOutputMap): string {
-	return template.replace(OUTPUT_REF_PATTERN, (rawReference, name: string) => {
-		if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) {
-			throw new ChainOutputValidationError(
-				`Invalid chain output reference '${rawReference}'. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`,
-			);
-		}
-		const entry = outputs[name];
-		if (!entry) throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}'.`);
-		return entry.text;
-	});
-}
-
-function compactStructuredText(value: unknown): string {
-	return JSON.stringify(value);
-}
-
-export function outputEntryFromResult(result: SingleResult, stepIndex: number): ChainOutputMapEntry {
-	return {
-		text:
-			result.structuredOutput !== undefined
-				? compactStructuredText(result.structuredOutput)
-				: getSingleResultOutput(result),
-		...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
-		agent: result.agent,
-		stepIndex,
-	};
-}
-
-export function outputEntryFromAsyncResult(
-	result: { agent: string; output: string; structuredOutput?: unknown },
-	stepIndex: number,
-): ChainOutputMapEntry {
-	return {
-		text: result.structuredOutput !== undefined ? compactStructuredText(result.structuredOutput) : result.output,
-		...(result.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
-		agent: result.agent,
-		stepIndex,
-	};
-}