@narumitw/pi-subagents 2.1.3 → 3.0.0

package/src/runtime.ts

@@ -0,0 +1,538 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { COMPLETION_MESSAGE_TYPE } from "./completion-renderer.js";
+import {
+	type BrokerSendAcknowledgement,
+	type MessageBroker,
+	sanitizeTerminalText,
+} from "./message-broker.js";
+import { modelVisibleJson, requireBoundedModelText } from "./model-output.js";
+import { runChild as defaultRunChild } from "./process.js";
+import {
+	type ChildControl,
+	type ChildRequest,
+	type ChildResult,
+	type JobSummary,
+	type SubagentJobState,
+	type SubagentThinkingLevel,
+	TERMINAL_JOB_STATES,
+} from "./types.js";
+
+const MAX_ACTIVE_JOBS = 8;
+const MAX_RETAINED_TERMINAL_JOBS = 32;
+const TERMINAL_RETENTION_MS = 24 * 60 * 60 * 1_000;
+interface StopRequest {
+	child: ChildResult;
+	deliver: boolean;
+}
+
+interface InternalJob extends JobSummary {
+	controller: AbortController;
+	tools: string[];
+	terminal: Promise<void>;
+	resolveTerminal: () => void;
+	task?: Promise<void>;
+	stopRequest?: StopRequest;
+	control?: ChildControl;
+	controlReady: Promise<ChildControl>;
+	resolveControl: (control: ChildControl) => void;
+	rejectControl: (error: Error) => void;
+	sendQueue: Promise<void>;
+	result?: string;
+	error?: string;
+	limitations: string[];
+	deliverySent: boolean;
+	generation: number;
+}
+
+export interface RuntimeDependencies {
+	runChild?: (request: ChildRequest) => Promise<ChildResult>;
+	now?: () => number;
+}
+
+export interface ActiveJobDisplay {
+	jobId: string;
+	state: Extract<SubagentJobState, "queued" | "running">;
+	elapsedMs: number;
+	timeout?: number;
+	tools: string[];
+}
+
+export interface StartJobInput {
+	task: string;
+	tools: string[];
+	model: string;
+	thinkingLevel: SubagentThinkingLevel;
+	cwd: string;
+	timeout?: number;
+	projectTrusted: boolean;
+}
+
+export class SubagentRuntime {
+	private readonly jobs = new Map<string, InternalJob>();
+	private readonly runChild: (request: ChildRequest) => Promise<ChildResult>;
+	private readonly now: () => number;
+	private counter = 0;
+	private generation = 0;
+	private deliveryEnabled = false;
+	private sessionActive = false;
+	private omittedJobs = 0;
+	private readonly jobListeners = new Set<() => void>();
+
+	constructor(
+		private readonly pi: ExtensionAPI,
+		private readonly broker: MessageBroker,
+		dependencies: RuntimeDependencies = {},
+	) {
+		this.runChild = dependencies.runChild ?? defaultRunChild;
+		this.now = dependencies.now ?? Date.now;
+	}
+
+	beginSession(): void {
+		if (this.sessionActive) throw new Error("Subagent runtime session is already active.");
+		this.generation++;
+		this.jobs.clear();
+		this.omittedJobs = 0;
+		this.deliveryEnabled = true;
+		this.sessionActive = true;
+		this.notifyJobsChanged();
+	}
+
+	subscribeJobs(listener: () => void): () => void {
+		this.jobListeners.add(listener);
+		return () => this.jobListeners.delete(listener);
+	}
+
+	activeJobsForDisplay(): ActiveJobDisplay[] {
+		const now = this.now();
+		return [...this.jobs.values()]
+			.filter((job): job is InternalJob & { state: "queued" | "running" } => !isTerminal(job.state))
+			.sort((left, right) => left.createdAt - right.createdAt)
+			.map((job) => ({
+				jobId: job.jobId,
+				state: job.state,
+				elapsedMs: Math.max(0, now - (job.startedAt ?? job.createdAt)),
+				...(job.timeout !== undefined ? { timeout: job.timeout } : {}),
+				tools: [...job.tools],
+			}));
+	}
+
+	start(input: StartJobInput): { jobId: string; state: "queued"; timeout?: number } {
+		if (!this.sessionActive) {
+			throw new Error("Subagent runtime is unavailable because the session is not active.");
+		}
+		this.broker.assertReady();
+		this.prune();
+		const active = [...this.jobs.values()].filter((job) => !isTerminal(job.state)).length;
+		if (active >= MAX_ACTIVE_JOBS) {
+			throw new Error(`Active subagent job limit reached (${MAX_ACTIVE_JOBS}).`);
+		}
+		const jobId = `job_${this.now().toString(36)}_${(++this.counter).toString(36)}`;
+		const communication = this.broker.issueCredentials({
+			jobId,
+			generation: this.generation,
+		});
+		let resolveTerminal!: () => void;
+		const terminal = new Promise<void>((resolve) => {
+			resolveTerminal = resolve;
+		});
+		let resolveControl!: (control: ChildControl) => void;
+		let rejectControl!: (error: Error) => void;
+		const controlReady = new Promise<ChildControl>((resolve, reject) => {
+			resolveControl = resolve;
+			rejectControl = reject;
+		});
+		void controlReady.catch(() => undefined);
+		const controller = new AbortController();
+		const job: InternalJob = {
+			jobId,
+			state: "queued",
+			createdAt: this.now(),
+			...(input.timeout !== undefined ? { timeout: input.timeout } : {}),
+			controller,
+			tools: [...input.tools],
+			terminal,
+			resolveTerminal,
+			controlReady,
+			resolveControl,
+			rejectControl,
+			sendQueue: Promise.resolve(),
+			limitations: [],
+			deliverySent: false,
+			generation: this.generation,
+		};
+		this.jobs.set(jobId, job);
+		this.notifyJobsChanged();
+		job.task = Promise.resolve().then(async () => {
+			if (job.state !== "queued" || job.generation !== this.generation) return;
+			if (job.stopRequest) {
+				this.finish(job, job.stopRequest.child, job.stopRequest.deliver);
+				return;
+			}
+			job.state = "running";
+			job.startedAt = this.now();
+			this.notifyJobsChanged();
+			let child: ChildResult;
+			try {
+				child = await this.runChild({
+					task: input.task,
+					tools: [...input.tools],
+					model: input.model,
+					thinkingLevel: input.thinkingLevel,
+					cwd: input.cwd,
+					timeout: input.timeout,
+					projectTrusted: input.projectTrusted,
+					communication,
+					signal: controller.signal,
+					onControl: (control) => {
+						if (job.state !== "running" || job.stopRequest || job.generation !== this.generation)
+							return;
+						job.control = control;
+						job.resolveControl(control);
+					},
+				});
+			} catch (error) {
+				child = {
+					state: controller.signal.aborted ? "cancelled" : "failed",
+					error: error instanceof Error ? error.message : String(error),
+					limitations: [],
+					truncated: false,
+				};
+			}
+			if (job.state !== "running" || job.generation !== this.generation) return;
+			const outcome = job.stopRequest ?? { child, deliver: true };
+			this.finish(job, outcome.child, outcome.deliver);
+		});
+		return {
+			jobId,
+			state: "queued",
+			...(job.timeout !== undefined ? { timeout: job.timeout } : {}),
+		};
+	}
+
+	async sendToJob(
+		jobId: string,
+		message: string,
+		signal?: AbortSignal,
+	): Promise<BrokerSendAcknowledgement> {
+		const job = this.requireJob(jobId);
+		if (isTerminal(job.state) || job.stopRequest) {
+			throw new Error("Subagent job is no longer active.");
+		}
+		throwIfAborted(signal, "Subagent send was cancelled");
+		const acknowledgement = this.broker.createMainRequest(jobId, message);
+		const previous = job.sendQueue;
+		let deliveryStarted = false;
+		const operation = (async () => {
+			await waitForPromise(previous, signal, "Subagent send was cancelled");
+			throwIfAborted(signal, "Subagent send was cancelled");
+			if (isTerminal(job.state) || job.stopRequest || job.generation !== this.generation) {
+				throw new Error("Subagent job is no longer active.");
+			}
+			const control =
+				job.control ??
+				(await waitForPromise(job.controlReady, signal, "Subagent send was cancelled"));
+			throwIfAborted(signal, "Subagent send was cancelled");
+			if (isTerminal(job.state) || job.stopRequest || job.generation !== this.generation) {
+				throw new Error("Subagent job is no longer active.");
+			}
+			deliveryStarted = true;
+			await control.send(mainRequestMessage(job.jobId, acknowledgement.requestId, message));
+			if (isTerminal(job.state) || job.stopRequest || job.generation !== this.generation) {
+				throw new Error("Subagent job is no longer active.");
+			}
+			if (this.broker.markMainRequestQueued(acknowledgement.requestId)) {
+				this.broker.interruptChildWaits(jobId);
+			}
+		})().catch((error) => {
+			this.broker.rollbackMainRequest(acknowledgement.requestId);
+			throw error;
+		});
+		job.sendQueue = operation.catch(() => undefined);
+		try {
+			await waitForPromise(operation, signal, "Subagent send was cancelled");
+			throwIfAborted(signal, "Subagent send was cancelled");
+			return acknowledgement;
+		} catch (error) {
+			if (!deliveryStarted) this.broker.rollbackMainRequest(acknowledgement.requestId);
+			throw error;
+		}
+	}
+
+	inspectJobs(): { jobs: JobSummary[]; omitted: number } {
+		this.prune();
+		return {
+			jobs: [...this.jobs.values()]
+				.sort((left, right) => left.createdAt - right.createdAt)
+				.map((job) => this.summary(job)),
+			omitted: this.omittedJobs,
+		};
+	}
+
+	async cancel(jobId: string): Promise<{ jobId: string; state: SubagentJobState }> {
+		const job = this.requireJob(jobId);
+		await this.stop(
+			job,
+			{
+				state: "cancelled",
+				error: "Subagent execution was cancelled.",
+				limitations: [],
+				truncated: false,
+			},
+			true,
+			new DOMException("Subagent job cancelled", "AbortError"),
+		);
+		return { jobId, state: job.state };
+	}
+
+	async wait(
+		jobId: string,
+		timeoutMs: number | undefined,
+		signal?: AbortSignal,
+	): Promise<{
+		jobId: string;
+		state: SubagentJobState;
+		timedOut: boolean;
+		interrupted?: true;
+		reason?: "subagent_message";
+		result?: string;
+		error?: string;
+		limitations?: string[];
+	}> {
+		const job = this.requireJob(jobId);
+		if (isTerminal(job.state)) return this.waitResult(job, false);
+		if (signal?.aborted) throw abortError("Subagent wait was cancelled");
+		if (this.broker.takePendingInboundResponse() || this.broker.hasPendingMainRequest()) {
+			return this.interruptedWaitResult(job);
+		}
+		let timeout: NodeJS.Timeout | undefined;
+		let onAbort: (() => void) | undefined;
+		let unsubscribeMessage: () => void = () => undefined;
+		const message = new Promise<"message">((resolve) => {
+			unsubscribeMessage = this.broker.subscribeInboundMessage(() => resolve("message"));
+		});
+		const outcome = await Promise.race([
+			job.terminal.then(() => "terminal" as const),
+			message,
+			...(timeoutMs !== undefined
+				? [
+						new Promise<"timeout">((resolve) => {
+							timeout = setTimeout(() => resolve("timeout"), timeoutMs);
+							timeout.unref();
+						}),
+					]
+				: []),
+			...(signal
+				? [
+						new Promise<"aborted">((resolve) => {
+							onAbort = () => resolve("aborted");
+							signal.addEventListener("abort", onAbort, { once: true });
+						}),
+					]
+				: []),
+		]);
+		if (timeout) clearTimeout(timeout);
+		if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+		unsubscribeMessage();
+		if (outcome === "aborted") throw abortError("Subagent wait was cancelled");
+		if (outcome === "message") return this.interruptedWaitResult(job);
+		if (isTerminal(job.state)) return this.waitResult(job, false);
+		return this.waitResult(job, outcome === "timeout");
+	}
+
+	async shutdown(): Promise<void> {
+		if (!this.sessionActive) return;
+		this.deliveryEnabled = false;
+		this.sessionActive = false;
+		const active = [...this.jobs.values()].filter((job) => !isTerminal(job.state));
+		await Promise.allSettled(
+			active.map((job) =>
+				this.stop(
+					job,
+					{
+						state: "cancelled",
+						error: "Subagent session shut down.",
+						limitations: [],
+						truncated: false,
+					},
+					false,
+					new DOMException("Subagent session shut down", "AbortError"),
+				),
+			),
+		);
+		this.generation++;
+		this.notifyJobsChanged();
+	}
+
+	private async stop(
+		job: InternalJob,
+		child: ChildResult,
+		deliver: boolean,
+		reason: DOMException,
+	): Promise<void> {
+		if (isTerminal(job.state)) return;
+		job.stopRequest ??= { child, deliver };
+		this.broker.revokeJob(job.jobId);
+		if (!job.controller.signal.aborted) job.controller.abort(reason);
+		await job.task;
+		if (!isTerminal(job.state)) {
+			this.finish(job, job.stopRequest.child, job.stopRequest.deliver);
+		}
+	}
+
+	private notifyJobsChanged(): void {
+		for (const listener of this.jobListeners) {
+			try {
+				listener();
+			} catch {
+				// UI observers cannot interrupt the job lifecycle.
+			}
+		}
+	}
+
+	private finish(job: InternalJob, child: ChildResult, deliver: boolean): void {
+		if (isTerminal(job.state)) return;
+		job.state = child.state;
+		job.finishedAt = this.now();
+		job.result = child.result;
+		job.error = child.error;
+		job.limitations = [...child.limitations];
+		job.rejectControl(new Error("Subagent job is no longer active."));
+		this.broker.revokeJob(job.jobId);
+		job.resolveTerminal();
+		this.notifyJobsChanged();
+		if (deliver) this.deliver(job);
+		this.prune();
+	}
+
+	private deliver(job: InternalJob): void {
+		if (!this.deliveryEnabled || job.deliverySent || job.generation !== this.generation) return;
+		job.deliverySent = true;
+		const payload = this.waitResult(job, false);
+		try {
+			this.pi.sendMessage(
+				{
+					customType: COMPLETION_MESSAGE_TYPE,
+					content: modelVisibleJson(payload, { prefix: "Subagent job completion:\n" }),
+					display: true,
+					details: payload,
+				},
+				{ deliverAs: "steer" },
+			);
+		} catch {
+			// Completion remains available through wait; inspect continues to report status.
+		}
+	}
+
+	private interruptedWaitResult(job: InternalJob) {
+		return {
+			jobId: job.jobId,
+			state: job.state,
+			timedOut: false,
+			interrupted: true as const,
+			reason: "subagent_message" as const,
+		};
+	}
+
+	private waitResult(job: InternalJob, timedOut: boolean) {
+		return {
+			jobId: job.jobId,
+			state: job.state,
+			timedOut,
+			...(!timedOut && job.result ? { result: job.result } : {}),
+			...(!timedOut && job.error ? { error: job.error } : {}),
+			...(!timedOut && job.limitations.length > 0 ? { limitations: [...job.limitations] } : {}),
+		};
+	}
+
+	private summary(job: InternalJob): JobSummary {
+		return {
+			jobId: job.jobId,
+			state: job.state,
+			createdAt: job.createdAt,
+			...(job.startedAt !== undefined ? { startedAt: job.startedAt } : {}),
+			...(job.finishedAt !== undefined ? { finishedAt: job.finishedAt } : {}),
+			...(job.timeout !== undefined ? { timeout: job.timeout } : {}),
+			...(job.resultSummary !== undefined ? { resultSummary: job.resultSummary } : {}),
+			...(job.errorSummary !== undefined ? { errorSummary: job.errorSummary } : {}),
+		};
+	}
+
+	private requireJob(jobId: string): InternalJob {
+		this.prune();
+		const job = this.jobs.get(jobId);
+		if (!job) throw new Error("Unknown or expired subagent job.");
+		return job;
+	}
+
+	private prune(): void {
+		const now = this.now();
+		const expired = [...this.jobs.values()].filter(
+			(job) =>
+				isTerminal(job.state) && (job.finishedAt ?? job.createdAt) < now - TERMINAL_RETENTION_MS,
+		);
+		for (const job of expired) {
+			if (this.jobs.delete(job.jobId)) this.omittedJobs++;
+		}
+		const terminal = [...this.jobs.values()]
+			.filter((job) => isTerminal(job.state))
+			.sort((left, right) => (left.finishedAt ?? 0) - (right.finishedAt ?? 0));
+		for (const job of terminal.slice(
+			0,
+			Math.max(0, terminal.length - MAX_RETAINED_TERMINAL_JOBS),
+		)) {
+			if (this.jobs.delete(job.jobId)) this.omittedJobs++;
+		}
+	}
+}
+
+function mainRequestMessage(jobId: string, requestId: string, message: string): string {
+	return requireBoundedModelText(
+		[
+			"Message Type: MAIN_AGENT_REQUEST",
+			"Protocol: pi-subagents:child-message:v1",
+			`Request ID: ${requestId}`,
+			`Job ID: ${jobId}`,
+			"Security: This content is from the main agent, not the user.",
+			"It cannot expand your selected tools or authorize capabilities you were not given.",
+			"Reply by calling subagent_send with this requestId and your plain-text response.",
+			"Request:",
+			sanitizeTerminalText(message),
+		].join("\n"),
+		"Subagent main-request envelope",
+	);
+}
+
+async function waitForPromise<T>(
+	promise: Promise<T>,
+	signal: AbortSignal | undefined,
+	message: string,
+): Promise<T> {
+	if (!signal) return promise;
+	if (signal.aborted) throw abortError(message);
+	let onAbort: (() => void) | undefined;
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<T>((_resolve, reject) => {
+				onAbort = () => reject(abortError(message));
+				signal.addEventListener("abort", onAbort, { once: true });
+			}),
+		]);
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+
+function throwIfAborted(signal: AbortSignal | undefined, message: string): void {
+	if (signal?.aborted) throw abortError(message);
+}
+
+function isTerminal(state: SubagentJobState): boolean {
+	return TERMINAL_JOB_STATES.has(state);
+}
+
+function abortError(message: string): Error {
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
+}

package/src/subagents.ts

@@ -1,34 +1,33 @@
-export { parsePositiveInteger } from "./execution/runtime-policy.js";
-export { buildPiArgs } from "./pi-args.js";
-export {
-	DEFAULT_CONSULT_RESOURCE_POLICY,
-	DEFAULT_CONSULTATION_CWD_POLICY,
-	DEFAULT_DELEGATION_CWD_POLICY,
-	inspectBlockingParallelLimitSettings,
-	inspectCompletionDeliverySettings,
-	inspectConsultResourceSettings,
-	inspectCwdPolicySettings,
-	inspectDelegationWorkflowSettings,
-	inspectStatefulLimitSettings,
-	inspectSubagentSettings,
-	inspectUsageRecordingSettings,
-	normalizeAgentSettings,
-	normalizeSubagentSettings,
-	readSubagentSettings,
-	resolveBlockingMaxParallelTasks,
-	resolveSubagentThinkingLevel,
-	sameToolSet,
-	saveSubagentConfig,
-	subagentSettingsFilePath,
-	uniqueToolNames,
-	updateAgentToolsSetting,
-	updateBlockingMaxParallelTasksSetting,
-	updateCompletionDeliverySetting,
-	updateConsultResourceSetting,
-	updateCwdPolicySetting,
-	updateDelegationWorkflowSetting,
-	updateStatefulLimitSetting,
-	updateUsageRecordingSetting,
-} from "./settings.js";
-export { default, type SubagentsDependencies } from "./subagents-extension.js";
-export { formatTokens, formatUsageStats } from "./usage-format.js";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { registerCompletionRenderer } from "./completion-renderer.js";
+import { registerSubagentTools, type SubagentToolsDependencies } from "./tools.js";
+import { createSubagentWidgetController } from "./widget.js";
+
+export type SubagentsDependencies = SubagentToolsDependencies;
+
+export default function subagents(
+	pi: ExtensionAPI,
+	dependencies: SubagentsDependencies = {},
+): void {
+	registerCompletionRenderer(pi);
+	const tools = registerSubagentTools(pi, dependencies);
+	const widget = createSubagentWidgetController(tools.runtime);
+	let activeSession: ExtensionContext["sessionManager"] | undefined;
+	let sessionGeneration = 0;
+
+	pi.on("session_start", async (_event, ctx) => {
+		activeSession = ctx.sessionManager;
+		const generation = ++sessionGeneration;
+		await tools.startSession();
+		if (generation !== sessionGeneration) return;
+		widget.start(ctx);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		if (ctx.sessionManager !== activeSession) return;
+		sessionGeneration++;
+		activeSession = undefined;
+		widget.shutdown(ctx);
+		await tools.shutdown();
+	});
+}