@narumitw/pi-subagents 0.13.0 → 0.13.1

package/README.md

@@ -256,14 +256,15 @@ Subagents are separate Pi processes and may use the tools allowed by their agent
 ```txt
 extensions/pi-subagents/
 ├── src/
-│   └── subagents.ts
+│   ├── subagents.ts  # Pi entrypoint and tool schema
+│   └── *.ts          # Package-local discovery, execution, rendering, and config modules
 ├── README.md
 ├── LICENSE
 ├── tsconfig.json
 └── package.json
 ```
 
-The package exposes its Pi extension through `package.json`:
+Only `subagents.ts` is a Pi entrypoint; the other source modules are internal. The package exposes its Pi extension through `package.json`:
 
 ```json
 {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "0.13.0",
+	"version": "0.13.1",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",

package/src/config-ui.ts

@@ -0,0 +1,271 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import {
+	Container,
+	Key,
+	matchesKey,
+	SelectList,
+	type SelectItem,
+	Spacer,
+	Text,
+	truncateToWidth,
+} from "@earendil-works/pi-tui";
+import { discoverAgents, type SubagentSettings } from "./agents.js";
+import {
+	hasAnyAgentOverride,
+	hasOwn,
+	readSubagentSettings,
+	sameToolSet,
+	saveSubagentConfig,
+	uniqueToolNames,
+} from "./settings.js";
+
+class ToolToggleList {
+	private items: { name: string; selected: boolean }[];
+	private cursor = 0;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+	onDone?: (selected: string[]) => void;
+	onCancel?: () => void;
+
+	constructor(tools: string[], selected: Set<string>) {
+		this.items = tools.map((name) => ({ name, selected: selected.has(name) }));
+	}
+
+	private getSelectedNames(): string[] {
+		return this.items.filter((i) => i.selected).map((i) => i.name);
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape)) {
+			this.onCancel?.();
+			return;
+		}
+		if (data === "s" || data === "S") {
+			this.onDone?.(this.getSelectedNames());
+			return;
+		}
+		if (this.items.length === 0) return;
+
+		if (matchesKey(data, Key.up) && this.cursor > 0) {
+			this.cursor--;
+			this.invalidate();
+		} else if (matchesKey(data, Key.down) && this.cursor < this.items.length - 1) {
+			this.cursor++;
+			this.invalidate();
+		} else if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
+			this.items[this.cursor].selected = !this.items[this.cursor].selected;
+			this.invalidate();
+		}
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		this.cachedWidth = width;
+		this.cachedLines = this.items.map((item, i) => {
+			const pointer = i === this.cursor ? ">" : " ";
+			const check = item.selected ? "✓" : "○";
+			return truncateToWidth(`${pointer} ${check} ${item.name}`, width);
+		});
+		return this.cachedLines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}
+
+export function registerSubagentConfigCommand(pi: ExtensionAPI) {
+	pi.registerCommand("subagents:config", {
+		description: "Configure which tools each subagent can use",
+		handler: async (_args, ctx) => {
+			if (!ctx.hasUI) {
+				return;
+			}
+
+			// Get current settings
+			const currentSettings = readSubagentSettings() ?? {};
+			const currentAgents = currentSettings.agents ?? {};
+
+			// Discover agents to show which ones are available
+			const discovery = discoverAgents(ctx.cwd, "user", currentSettings);
+			const agents = discovery.agents;
+
+			if (agents.length === 0) {
+				ctx.ui.notify("No agents found", "warning");
+				return;
+			}
+
+			// Loop: agent selection → tool toggle (Esc in tools returns here)
+			while (true) {
+				// Step 1: pick an agent to configure
+				const agentItems: SelectItem[] = agents.map((a) => {
+					const cfg = currentAgents[a.name];
+					const hasToolsOverride = cfg ? hasOwn(cfg, "tools") : false;
+					const toolSummary = hasToolsOverride
+						? cfg?.tools && cfg.tools.length > 0
+							? cfg.tools.join(", ")
+							: "none"
+						: "defaults";
+					return {
+						value: a.name,
+						label: a.name,
+						description: `${a.source} · tools: ${toolSummary}`,
+					};
+				});
+
+				const agentName = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+					const container = new Container();
+					container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+					container.addChild(
+						new Text(theme.fg("accent", theme.bold("Subagent Tool Configuration")), 1, 0),
+					);
+					container.addChild(new Spacer(1));
+					container.addChild(
+						new Text(theme.fg("muted", "Select an agent to configure its allowed tools:"), 1, 0),
+					);
+					container.addChild(new Spacer(1));
+					const selectList = new SelectList(agentItems, Math.min(agentItems.length + 2, 15), {
+						selectedPrefix: (t: string) => theme.fg("accent", t),
+						selectedText: (t: string) => theme.fg("accent", t),
+						description: (t: string) => theme.fg("muted", t),
+						scrollInfo: (t: string) => theme.fg("dim", t),
+						noMatch: (t: string) => theme.fg("warning", t),
+					});
+					selectList.onSelect = (item) => done(item.value);
+					selectList.onCancel = () => done(null);
+					container.addChild(selectList);
+					container.addChild(
+						new Text(theme.fg("dim", "↑↓ navigate · enter select · esc cancel"), 1, 0),
+					);
+					container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+					return {
+						render: (w: number) => container.render(w),
+						invalidate: () => container.invalidate(),
+						handleInput: (data: string) => {
+							selectList.handleInput(data);
+							tui.requestRender();
+						},
+					};
+				});
+
+				if (!agentName) return;
+
+				const agent = agents.find((a) => a.name === agentName);
+				if (!agent) return;
+
+				// Step 2: toggle tools for the selected agent
+				// Discover without overrides to get original built-in/frontmatter defaults.
+				// The main discovery above applies saved overrides, so agent.tools is already
+				// overridden — using it for the reset-to-default comparison would match the
+				// override against itself and silently delete it on a no-op save.
+				const defaultDiscovery = discoverAgents(ctx.cwd, "user");
+				const defaultTools = defaultDiscovery.agents.find((a) => a.name === agentName)?.tools;
+				const currentAgentSettings = currentAgents[agentName];
+				const configuredTools =
+					currentAgentSettings && hasOwn(currentAgentSettings, "tools")
+						? (currentAgentSettings.tools ?? [])
+						: undefined;
+
+				// Get all available tools from pi's registry
+				const allTools = uniqueToolNames(pi.getAllTools().map((t) => t.name)).sort((a, b) =>
+					a.localeCompare(b),
+				);
+				const currentTools = uniqueToolNames(configuredTools ?? defaultTools ?? allTools);
+				// Sort: currently selected tools first, then rest alphabetically. Preserve
+				// unavailable configured tools so saving does not silently drop them.
+				const currentSet = new Set(currentTools);
+				const selectedFirst = [...currentTools, ...allTools.filter((t) => !currentSet.has(t))];
+
+				const selectedTools = await ctx.ui.custom<string[] | null>((tui, theme, _kb, done) => {
+					const toggleList = new ToolToggleList(selectedFirst, currentSet);
+
+					const container = new Container();
+					container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+					container.addChild(
+						new Text(
+							theme.fg("accent", theme.bold(`${agentName} tools`)) +
+								theme.fg("muted", ` (${agent.source})`),
+							1,
+							0,
+						),
+					);
+					container.addChild(new Spacer(1));
+					container.addChild(
+						new Text(theme.fg("muted", "Toggle tools with Enter/Space. S to save, Esc to cancel."), 1, 0),
+					);
+					container.addChild(new Spacer(1));
+
+					const listContainer = new Container();
+					listContainer.addChild({
+						render: (w: number) => toggleList.render(w),
+						invalidate: () => toggleList.invalidate(),
+					});
+					container.addChild(listContainer);
+
+					container.addChild(new Spacer(1));
+					container.addChild(
+						new Text(theme.fg("dim", "↑↓ navigate · enter/space toggle · S save · esc cancel"), 1, 0),
+					);
+					container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+					toggleList.onDone = (tools) => done(tools);
+					toggleList.onCancel = () => done(null);
+
+					return {
+						render: (w: number) => container.render(w),
+						invalidate: () => container.invalidate(),
+						handleInput: (data: string) => {
+							toggleList.handleInput(data);
+							tui.requestRender();
+						},
+					};
+				});
+
+				// null means user cancelled — loop back to agent selection
+				if (selectedTools === null) continue;
+
+				// Save to global settings
+				const updatedAgents = { ...currentAgents };
+				let restoredDefaults = false;
+
+				const isSameAsDefault =
+					defaultTools === undefined
+						? sameToolSet(selectedTools, allTools)
+						: sameToolSet(selectedTools, defaultTools);
+
+				if (isSameAsDefault) {
+					// Tools match defaults — remove only the tools override.
+					// Keep other settings (model, timeoutMs) if present.
+					const existing = updatedAgents[agentName];
+					if (existing) {
+						const nextConfig = { ...existing };
+						delete nextConfig.tools;
+						if (hasAnyAgentOverride(nextConfig)) updatedAgents[agentName] = nextConfig;
+						else delete updatedAgents[agentName];
+					}
+					restoredDefaults = true;
+				} else {
+					updatedAgents[agentName] = {
+						...updatedAgents[agentName],
+						tools: selectedTools,
+					};
+				}
+
+				const newSettings: SubagentSettings = {
+					...currentSettings,
+					agents: Object.keys(updatedAgents).length > 0 ? updatedAgents : undefined,
+				};
+
+				saveSubagentConfig(newSettings);
+				const message = restoredDefaults
+					? `${agentName}: defaults restored`
+					: `${agentName}: ${selectedTools.length} tool${selectedTools.length !== 1 ? "s" : ""} configured`;
+				ctx.ui.notify(message, "info");
+				// Saved — exit the loop
+				break;
+			}
+		},
+	});
+}

package/src/execution.ts

@@ -0,0 +1,406 @@
+import type { AgentToolResult, AgentToolUpdateCallback } from "@earendil-works/pi-agent-core";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	discoverAgents,
+	type AgentConfig,
+	type AgentScope,
+	type SubagentThinkingLevel,
+} from "./agents.js";
+import {
+	buildFanInContext,
+	getResultFinalOutput,
+	mapWithConcurrencyLimit,
+	runSingleAgent,
+	type OnUpdateCallback,
+	type SingleResult,
+	type SubagentDetails,
+} from "./runner.js";
+import type { SubagentParams } from "./params.js";
+import { readSubagentSettings, resolveSubagentThinkingLevel } from "./settings.js";
+
+const MAX_PARALLEL_TASKS = 8;
+const MAX_CONCURRENCY = 4;
+const DEFAULT_TIMEOUT_MS = parsePositiveInteger(process.env.PI_SUBAGENT_TIMEOUT_MS) ?? 10 * 60 * 1000;
+const STATUS_KEY = "subagents";
+const activeStatuses = new Map<string, string>();
+
+export function parsePositiveInteger(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+interface StatusContext {
+	ui: { setStatus: (key: string, value: string | undefined) => void };
+}
+
+function startSubagentStatus(ctx: StatusContext, toolCallId: string, status: string) {
+	let cleared = false;
+
+	const update = (nextStatus: string) => {
+		if (cleared) return;
+		activeStatuses.set(toolCallId, nextStatus);
+		publishSubagentStatus(ctx);
+	};
+
+	update(status);
+
+	return {
+		update,
+		clear() {
+			if (cleared) return;
+			cleared = true;
+			activeStatuses.delete(toolCallId);
+			publishSubagentStatus(ctx);
+		},
+	};
+}
+
+function publishSubagentStatus(ctx: StatusContext) {
+	const statuses = [...activeStatuses.values()];
+	if (statuses.length === 0) {
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		return;
+	}
+
+	const suffix = statuses.length > 1 ? ` +${statuses.length - 1}` : "";
+	ctx.ui.setStatus(STATUS_KEY, `${statuses[0]}${suffix}`);
+}
+
+function singleStatus(agent: string): string {
+	return `${agent}`;
+}
+
+function chainStatus(step: number, total: number, agent?: string): string {
+	return `chain ${step}/${total}${agent ? ` ${agent}` : ""}`;
+}
+
+function parallelStatus(done: number, total: number, running: number): string {
+	return `parallel ${done}/${total} done${running > 0 ? ` ${running} running` : ""}`;
+}
+
+function fanInStatus(agent: string): string {
+	return `fan-in ${agent}`;
+}
+
+export async function executeSubagent(
+	toolCallId: string,
+	params: SubagentParams,
+	signal: AbortSignal | undefined,
+	onUpdate: AgentToolUpdateCallback<SubagentDetails> | undefined,
+	ctx: ExtensionContext,
+): Promise<AgentToolResult<SubagentDetails> & { isError?: boolean }> {
+			const agentScope: AgentScope = params.agentScope ?? "user";
+			const config = readSubagentSettings();
+			const discovery = discoverAgents(ctx.cwd, agentScope, config);
+			const agents = discovery.agents;
+			const confirmProjectAgents = params.confirmProjectAgents ?? true;
+			const resolveTimeoutMs = (agentName: string, localTimeoutMs?: number) =>
+				localTimeoutMs ??
+				params.timeoutMs ??
+				agents.find((agent) => agent.name === agentName)?.timeoutMs ??
+				DEFAULT_TIMEOUT_MS;
+			const resolveThinkingLevel = (agentName: string, localThinkingLevel?: SubagentThinkingLevel) =>
+				resolveSubagentThinkingLevel(agents, agentName, params.thinkingLevel, localThinkingLevel);
+
+			const hasChain = (params.chain?.length ?? 0) > 0;
+			const hasTasks = (params.tasks?.length ?? 0) > 0;
+			const hasSingle = Boolean(params.agent && params.task);
+			const modeCount = Number(hasChain) + Number(hasTasks) + Number(hasSingle);
+
+			const makeDetails =
+				(mode: "single" | "parallel" | "chain") =>
+				(results: SingleResult[], aggregator?: SingleResult): SubagentDetails => ({
+					mode,
+					agentScope,
+					projectAgentsDir: discovery.projectAgentsDir,
+					results,
+					aggregator,
+				});
+
+			if (modeCount !== 1 || (params.aggregator && !hasTasks)) {
+				const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
+				const reason =
+					modeCount !== 1
+						? "Provide exactly one mode."
+						: "Aggregator is only valid with parallel tasks.";
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Invalid parameters. ${reason}\nAvailable agents: ${available}`,
+						},
+					],
+					details: makeDetails("single")([]),
+				};
+			}
+
+			if ((agentScope === "project" || agentScope === "both") && confirmProjectAgents && ctx.hasUI) {
+				const requestedAgentNames = new Set<string>();
+				if (params.chain) for (const step of params.chain) requestedAgentNames.add(step.agent);
+				if (params.tasks) for (const t of params.tasks) requestedAgentNames.add(t.agent);
+				if (params.aggregator) requestedAgentNames.add(params.aggregator.agent);
+				if (params.agent) requestedAgentNames.add(params.agent);
+
+				const projectAgentsRequested = Array.from(requestedAgentNames)
+					.map((name) => agents.find((a) => a.name === name))
+					.filter((a): a is AgentConfig => a?.source === "project");
+
+				if (projectAgentsRequested.length > 0) {
+					const names = projectAgentsRequested.map((a) => a.name).join(", ");
+					const dir = discovery.projectAgentsDir ?? "(unknown)";
+					const ok = await ctx.ui.confirm(
+						"Run project-local agents?",
+						`Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
+					);
+					if (!ok)
+						return {
+							content: [{ type: "text", text: "Canceled: project-local agents not approved." }],
+							details: makeDetails(hasChain ? "chain" : hasTasks ? "parallel" : "single")([]),
+						};
+				}
+			}
+
+			if (params.chain && params.chain.length > 0) {
+				const results: SingleResult[] = [];
+				let previousOutput = "";
+				const status = startSubagentStatus(ctx, toolCallId, chainStatus(0, params.chain.length));
+
+				try {
+					for (let i = 0; i < params.chain.length; i++) {
+						const step = params.chain[i];
+						status.update(chainStatus(i + 1, params.chain.length, step.agent));
+						const taskWithContext = step.task.replace(/\{previous\}/g, previousOutput);
+
+						// Create update callback that includes all previous results
+						const chainUpdate: OnUpdateCallback | undefined = onUpdate
+							? (partial) => {
+									// Combine completed results with current streaming result
+									const currentResult = partial.details?.results[0];
+									if (currentResult) {
+										const allResults = [...results, currentResult];
+										onUpdate({
+											content: partial.content,
+											details: makeDetails("chain")(allResults),
+										});
+									}
+								}
+							: undefined;
+
+						const result = await runSingleAgent(
+							ctx.cwd,
+							agents,
+							step.agent,
+							taskWithContext,
+							step.cwd,
+							i + 1,
+							signal,
+							resolveThinkingLevel(step.agent, step.thinkingLevel),
+							resolveTimeoutMs(step.agent, step.timeoutMs),
+							chainUpdate,
+							makeDetails("chain"),
+						);
+						results.push(result);
+
+						const isError =
+							result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+						if (isError) {
+							const errorMsg = result.errorMessage || result.stderr || getResultFinalOutput(result) || "(no output)";
+							return {
+								content: [{ type: "text", text: `Chain stopped at step ${i + 1} (${step.agent}): ${errorMsg}` }],
+								details: makeDetails("chain")(results),
+								isError: true,
+							};
+						}
+						previousOutput = getResultFinalOutput(result);
+					}
+					return {
+						content: [{ type: "text", text: getResultFinalOutput(results[results.length - 1]) || "(no output)" }],
+						details: makeDetails("chain")(results),
+					};
+				} finally {
+					status.clear();
+				}
+			}
+
+			if (params.tasks && params.tasks.length > 0) {
+				if (params.tasks.length > MAX_PARALLEL_TASKS)
+					return {
+						content: [
+							{
+								type: "text",
+								text: `Too many parallel tasks (${params.tasks.length}). Max is ${MAX_PARALLEL_TASKS}.`,
+							},
+						],
+						details: makeDetails("parallel")([]),
+					};
+
+				const status = startSubagentStatus(ctx, toolCallId, parallelStatus(0, params.tasks.length, params.tasks.length));
+
+				try {
+					// Track all results for streaming updates
+					const allResults: SingleResult[] = new Array(params.tasks.length);
+
+					// Initialize placeholder results
+					for (let i = 0; i < params.tasks.length; i++) {
+						allResults[i] = {
+							agent: params.tasks[i].agent,
+							agentSource: "unknown",
+							task: params.tasks[i].task,
+							exitCode: -1, // -1 = still running
+							messages: [],
+							stderr: "",
+							usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+							thinkingLevel: resolveThinkingLevel(params.tasks[i].agent, params.tasks[i].thinkingLevel),
+							finalOutput: "",
+						};
+					}
+
+					let doneCount = 0;
+					let runningCount = params.tasks.length;
+
+					const emitParallelUpdate = () => {
+						status.update(parallelStatus(doneCount, allResults.length, runningCount));
+						if (onUpdate) {
+							onUpdate({
+								content: [
+									{
+										type: "text",
+										text: `Parallel: ${doneCount}/${allResults.length} done, ${runningCount} running...`,
+									},
+								],
+								details: makeDetails("parallel")([...allResults]),
+							});
+						}
+					};
+
+					const results = await mapWithConcurrencyLimit(params.tasks, MAX_CONCURRENCY, async (t, index) => {
+						const result = await runSingleAgent(
+							ctx.cwd,
+							agents,
+							t.agent,
+							t.task,
+							t.cwd,
+							undefined,
+							signal,
+							resolveThinkingLevel(t.agent, t.thinkingLevel),
+							resolveTimeoutMs(t.agent, t.timeoutMs),
+							// Per-task update callback
+							(partial) => {
+								if (partial.details?.results[0]) {
+									allResults[index] = { ...partial.details.results[0], exitCode: -1 };
+									emitParallelUpdate();
+								}
+							},
+							makeDetails("parallel"),
+						);
+						allResults[index] = result;
+						doneCount += 1;
+						runningCount -= 1;
+						emitParallelUpdate();
+						return result;
+					});
+
+					let aggregatorResult: SingleResult | undefined;
+					if (params.aggregator) {
+						const aggregator = params.aggregator;
+						status.update(fanInStatus(aggregator.agent));
+						const fanInContext = buildFanInContext(results);
+						const aggregatorTask = aggregator.task.includes("{previous}")
+							? aggregator.task.replace(/\{previous\}/g, fanInContext)
+							: `${aggregator.task}\n\nParallel task outputs:\n\n${fanInContext}`;
+						aggregatorResult = await runSingleAgent(
+							ctx.cwd,
+							agents,
+							aggregator.agent,
+							aggregatorTask,
+							aggregator.cwd,
+							undefined,
+							signal,
+							resolveThinkingLevel(aggregator.agent, aggregator.thinkingLevel),
+							resolveTimeoutMs(aggregator.agent, aggregator.timeoutMs),
+							(partial) => {
+								status.update(fanInStatus(aggregator.agent));
+								if (onUpdate && partial.details?.results[0]) {
+									onUpdate({
+										content: partial.content,
+										details: makeDetails("parallel")(results, partial.details.results[0]),
+									});
+								}
+							},
+							makeDetails("parallel"),
+						);
+					}
+
+					const successCount = results.filter((r) => r.exitCode === 0).length;
+					const summaries = results.map((r) => {
+						const output = getResultFinalOutput(r);
+						const error = r.errorMessage || r.stderr.trim();
+						const summaryText = output || error;
+						const preview = summaryText.slice(0, 160) + (summaryText.length > 160 ? "..." : "");
+						return `[${r.agent}] ${r.exitCode === 0 ? "completed" : "failed"}: ${preview || "(no output)"}`;
+					});
+					const aggregatorOutput = aggregatorResult ? getResultFinalOutput(aggregatorResult) : "";
+					const aggregatorError = aggregatorResult?.errorMessage || aggregatorResult?.stderr.trim() || "";
+					return {
+						content: [
+							{
+								type: "text",
+								text: aggregatorResult
+									? aggregatorOutput || aggregatorError || `(aggregator ${aggregatorResult.agent} produced no output)`
+									: `Parallel: ${successCount}/${results.length} succeeded\n\n${summaries.join("\n\n")}`,
+							},
+						],
+						details: makeDetails("parallel")(results, aggregatorResult),
+						isError: aggregatorResult
+							? aggregatorResult.exitCode !== 0 ||
+								aggregatorResult.stopReason === "error" ||
+								aggregatorResult.stopReason === "aborted"
+							: undefined,
+					};
+				} finally {
+					status.clear();
+				}
+			}
+
+			if (params.agent && params.task) {
+				const status = startSubagentStatus(ctx, toolCallId, singleStatus(params.agent));
+
+				try {
+					const result = await runSingleAgent(
+						ctx.cwd,
+						agents,
+						params.agent,
+						params.task,
+						params.cwd,
+						undefined,
+						signal,
+						resolveThinkingLevel(params.agent, params.thinkingLevel),
+						resolveTimeoutMs(params.agent, params.timeoutMs),
+						onUpdate,
+						makeDetails("single"),
+					);
+					const isError = result.exitCode !== 0 || result.stopReason === "error" || result.stopReason === "aborted";
+					if (isError) {
+						const errorMsg = result.errorMessage || result.stderr || getResultFinalOutput(result) || "(no output)";
+						return {
+							content: [{ type: "text", text: `Agent ${result.stopReason || "failed"}: ${errorMsg}` }],
+							details: makeDetails("single")([result]),
+							isError: true,
+						};
+					}
+					return {
+						content: [{ type: "text", text: getResultFinalOutput(result) || "(no output)" }],
+						details: makeDetails("single")([result]),
+					};
+				} finally {
+					status.clear();
+				}
+			}
+
+			const available = agents.map((a) => `${a.name} (${a.source})`).join(", ") || "none";
+			return {
+				content: [{ type: "text", text: `Invalid parameters. Available agents: ${available}` }],
+				details: makeDetails("single")([]),
+			};
+}