@narumitw/pi-subagents 0.15.1 → 0.17.0

package/src/runner.ts

@@ -5,12 +5,7 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import type {
-	AgentConfig,
-	AgentScope,
-	AgentSource,
-	SubagentThinkingLevel,
-} from "./agents.js";
+import type { AgentConfig, AgentScope, AgentSource, SubagentThinkingLevel } from "./agents.js";
 import {
 	appendBounded,
 	DEFAULT_MAX_CONTEXT_BYTES,
@@ -32,6 +27,13 @@ export interface UsageStats {
 	contextTokens: number;
 	turns: number;
 }
+export type RecentActivityItem =
+	| { type: "text"; text: string }
+	| { type: "toolCall"; name: string; args: Record<string, unknown> };
+
+const MAX_RECENT_ACTIVITY_ITEMS = 10;
+const MAX_RECENT_ACTIVITY_BYTES = 8 * 1024;
+const MAX_RECENT_ACTIVITY_ARGUMENT_BYTES = 1024;
 
 export interface SingleResult {
 	agent: string;
@@ -42,6 +44,10 @@ export interface SingleResult {
 	stderr: string;
 	usage: UsageStats;
 	model?: string;
+	actualProvider?: string;
+	actualModel?: string;
+	recentActivity?: RecentActivityItem[];
+	recentActivityTotal?: number;
 	thinkingLevel?: SubagentThinkingLevel;
 	stopReason?: string;
 	errorMessage?: string;
@@ -72,9 +78,11 @@ function getFinalOutput(messages: Message[]): string {
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i];
 		if (msg.role === "assistant") {
-			for (const part of msg.content) {
-				if (part.type === "text") return part.text;
-			}
+			const text = msg.content
+				.filter((part) => part.type === "text")
+				.map((part) => part.text)
+				.join("\n");
+			if (text) return text;
 		}
 	}
 	return "";
@@ -84,36 +92,157 @@ export function getResultFinalOutput(result: SingleResult): string {
 	return result.finalOutput ?? getFinalOutput(result.messages);
 }
 
-function boundMessageText(message: Message, maxBytes: number): { message: Message; bytes: number; truncated: boolean } {
-	const serializedBytes = Buffer.byteLength(JSON.stringify(message), "utf8");
-	if (serializedBytes <= maxBytes) return { message, bytes: serializedBytes, truncated: false };
-	if (!Array.isArray(message.content)) return { message, bytes: Math.min(serializedBytes, maxBytes), truncated: true };
-	let remaining = maxBytes;
-	const content = message.content
-		.filter((part) => part.type === "text")
-		.map((part) => {
-			const bounded = truncateUtf8(part.text, remaining);
-			remaining = Math.max(0, remaining - Buffer.byteLength(bounded.text, "utf8"));
-			return { ...part, text: bounded.text };
-		});
-	const boundedMessage = { ...message, content } as Message;
-	return {
-		message: boundedMessage,
-		bytes: Math.min(Buffer.byteLength(JSON.stringify(boundedMessage), "utf8"), maxBytes),
-		truncated: true,
+export function isResultError(result: SingleResult): boolean {
+	return (
+		(result.exitCode !== 0 && result.exitCode !== -1) ||
+		result.timedOut === true ||
+		result.stopReason === "timeout" ||
+		result.stopReason === "error" ||
+		result.stopReason === "aborted"
+	);
+}
+
+export function formatResultFailure(result: SingleResult): string {
+	const error = result.errorMessage || result.stderr.trim();
+	const output = getResultFinalOutput(result);
+	const combined =
+		error && output ? `${error}\n\nPartial output:\n${output}` : error || output || "(no output)";
+	return truncateUtf8(combined, DEFAULT_MAX_CONTEXT_BYTES).text;
+}
+
+function boundMessageText(
+	message: Message,
+	maxBytes: number,
+): { message?: Message; bytes: number; truncated: boolean } {
+	const originalBytes = Buffer.byteLength(JSON.stringify(message), "utf8");
+	if (Number.isSafeInteger(maxBytes) && maxBytes >= 0 && originalBytes <= maxBytes) {
+		return { message, bytes: originalBytes, truncated: false };
+	}
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) return { bytes: 0, truncated: true };
+
+	const content: Array<
+		| { type: "text"; text: string }
+		| { type: "toolCall"; id: string; name: string; arguments: Record<string, unknown> }
+	> = [];
+	const bounded = () => ({ ...message, content }) as Message;
+	const fits = () => Buffer.byteLength(JSON.stringify(bounded()), "utf8") <= maxBytes;
+	const addText = (text: string, prepend = false) => {
+		if (!text.trim()) return;
+		const part = { type: "text" as const, text: "" };
+		if (prepend) content.unshift(part);
+		else content.push(part);
+		if (!fits()) {
+			content.splice(content.indexOf(part), 1);
+			return;
+		}
+		let low = 0;
+		let high = Buffer.byteLength(text, "utf8");
+		while (low < high) {
+			const middle = Math.ceil((low + high) / 2);
+			part.text = truncateUtf8(text, middle).text;
+			if (fits()) low = middle;
+			else high = middle - 1;
+		}
+		part.text = truncateUtf8(text, low).text;
+		if (!part.text.trim()) content.splice(content.indexOf(part), 1);
+	};
+	const addToolCall = (part: Extract<Message["content"][number], { type: "toolCall" }>) => {
+		const toolCall = {
+			type: "toolCall" as const,
+			id: part.id,
+			name: part.name,
+			arguments: part.arguments,
+		};
+		content.unshift(toolCall);
+		if (fits()) return;
+		const arguments_: Record<string, unknown> = {};
+		for (const key of ["command", "path", "file_path", "pattern", "url"]) {
+			const value = part.arguments[key];
+			if (typeof value === "string") arguments_[key] = truncateUtf8(value, 256).text;
+		}
+		toolCall.arguments = arguments_;
+		if (fits()) return;
+		toolCall.arguments = {};
+		if (!fits()) content.shift();
 	};
+
+	if (message.role === "assistant") {
+		for (let index = message.content.length - 1; index >= 0; index--) {
+			const part = message.content[index];
+			if (part.type === "text") addText(part.text, true);
+			else if (part.type === "toolCall") addToolCall(part);
+		}
+	} else {
+		for (const part of message.content) {
+			if (typeof part === "object" && part && part.type === "text") addText(part.text);
+		}
+	}
+
+	if (content.length === 0) return { bytes: 0, truncated: true };
+	const result = bounded();
+	const bytes = Buffer.byteLength(JSON.stringify(result), "utf8");
+	return { message: result, bytes, truncated: true };
+}
+function compactRecentActivityArguments(args: Record<string, unknown>): Record<string, unknown> {
+	if (Buffer.byteLength(JSON.stringify(args), "utf8") <= MAX_RECENT_ACTIVITY_ARGUMENT_BYTES)
+		return args;
+	const compact: Record<string, unknown> = {};
+	for (const key of ["command", "path", "file_path", "pattern", "url", "selector"]) {
+		const value = args[key];
+		if (typeof value === "string") compact[key] = truncateUtf8(value, 256).text;
+		else if (typeof value === "number" || typeof value === "boolean") compact[key] = value;
+	}
+	return compact;
 }
 
-export function buildFanInContext(results: SingleResult[], maxBytes = DEFAULT_MAX_CONTEXT_BYTES): string {
+function appendRecentActivity(result: SingleResult, message: Message): void {
+	if (message.role !== "assistant") return;
+	const append = (item: RecentActivityItem) => {
+		result.recentActivity ??= [];
+		result.recentActivityTotal = (result.recentActivityTotal ?? 0) + 1;
+		result.recentActivity.push(item);
+		if (result.recentActivity.length > MAX_RECENT_ACTIVITY_ITEMS) {
+			result.recentActivity.splice(0, result.recentActivity.length - MAX_RECENT_ACTIVITY_ITEMS);
+		}
+		while (
+			Buffer.byteLength(JSON.stringify(result.recentActivity), "utf8") > MAX_RECENT_ACTIVITY_BYTES
+		) {
+			result.recentActivity.shift();
+		}
+	};
+	for (const part of message.content) {
+		if (part.type === "text") {
+			const text = part.text.trim();
+			if (text) append({ type: "text", text: truncateUtf8(text, 1024).text });
+		} else if (part.type === "toolCall") {
+			append({
+				type: "toolCall",
+				name: part.name,
+				args: compactRecentActivityArguments(part.arguments),
+			});
+		}
+	}
+}
+
+export function buildFanInContext(
+	results: SingleResult[],
+	maxBytes = DEFAULT_MAX_CONTEXT_BYTES,
+): string {
 	const text = results
 		.map((result, index) => {
-			const status = result.exitCode === 0 ? "completed" : result.exitCode === -1 ? "running" : "failed";
+			const failed = isResultError(result);
+			const status = result.exitCode === -1 ? "running" : failed ? "failed" : "completed";
 			const output = getResultFinalOutput(result);
 			const error = result.errorMessage || result.stderr.trim();
+			const resultText = failed
+				? `${error ? "Error" : output ? "Partial output" : "Error"}:\n${formatResultFailure(result)}`
+				: output
+					? `Output:\n${output}`
+					: "Output: (no output)";
 			return [
 				`## Result ${index + 1}: ${result.agent} (${status})`,
 				`Task: ${result.task}`,
-				output ? `Output:\n${output}` : error ? `Error:\n${error}` : "Output: (no output)",
+				resultText,
 			].join("\n\n");
 		})
 		.join("\n\n---\n\n");
@@ -146,7 +275,10 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 	return results;
 }
 
-async function writePromptToTempFile(agentName: string, prompt: string): Promise<{ dir: string; filePath: string }> {
+async function writePromptToTempFile(
+	agentName: string,
+	prompt: string,
+): Promise<{ dir: string; filePath: string }> {
 	const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "pi-subagent-"));
 	const safeName = agentName.replace(/[^\w.-]+/g, "_");
 	const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
@@ -207,8 +339,15 @@ function signalProcess(proc: ReturnType<typeof spawn>, signal: NodeJS.Signals):
 	}
 }
 
-export function terminateProcess(proc: ReturnType<typeof spawn>, graceMs = KILL_GRACE_MS): () => void {
-	let closed = proc.exitCode !== null || proc.signalCode !== null;
+export function terminateProcess(
+	proc: ReturnType<typeof spawn>,
+	graceMs = KILL_GRACE_MS,
+): () => void {
+	const leaderExited = proc.exitCode !== null || proc.signalCode !== null;
+	const capturedOutputClosed = [proc.stdout, proc.stderr].every(
+		(stream) => !stream || stream.readableEnded || stream.destroyed,
+	);
+	let closed = leaderExited && capturedOutputClosed;
 	const onClose = () => {
 		closed = true;
 	};
@@ -251,7 +390,15 @@ export async function runSingleAgent(
 			exitCode: 1,
 			messages: [],
 			stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
-			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+			usage: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				cost: 0,
+				contextTokens: 0,
+				turns: 0,
+			},
 			thinkingLevel,
 			step,
 			finalOutput: "",
@@ -261,6 +408,9 @@ export async function runSingleAgent(
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;
 
+	let latestAssistantOutput = "";
+	let terminalAssistantOutput: string | undefined;
+
 	const currentResult: SingleResult = {
 		agent: agentName,
 		agentSource: agent.source,
@@ -268,15 +418,35 @@ export async function runSingleAgent(
 		exitCode: 0,
 		messages: [],
 		stderr: "",
-		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			cost: 0,
+			contextTokens: 0,
+			turns: 0,
+		},
 		model: agent.model ?? undefined,
 		thinkingLevel,
 		step,
 		timeoutMs,
 	};
+	const selectedAssistantOutput = () =>
+		terminalAssistantOutput !== undefined
+			? terminalAssistantOutput
+			: latestAssistantOutput || getFinalOutput(currentResult.messages);
+	const setErrorMessage = (message: string) => {
+		const bounded = truncateUtf8(message, DEFAULT_MAX_STDERR_BYTES);
+		currentResult.errorMessage = bounded.text;
+		currentResult.truncated ||= bounded.truncated;
+		return bounded.text;
+	};
 
 	const emitUpdate = () => {
-		currentResult.finalOutput = getFinalOutput(currentResult.messages);
+		const latest = truncateUtf8(selectedAssistantOutput(), DEFAULT_MAX_OUTPUT_BYTES);
+		currentResult.finalOutput = latest.text;
+		currentResult.truncated ||= latest.truncated;
 		if (onUpdate) {
 			onUpdate({
 				content: [{ type: "text", text: currentResult.finalOutput || "(running...)" }],
@@ -293,8 +463,7 @@ export async function runSingleAgent(
 			currentResult.exitCode = 1;
 			currentResult.stopReason = "error";
 			const reason = error instanceof Error ? error.message : String(error);
-			currentResult.errorMessage = `Invalid subagent cwd: ${effectiveCwd} (${reason})`;
-			currentResult.stderr = currentResult.errorMessage;
+			currentResult.stderr = setErrorMessage(`Invalid subagent cwd: ${effectiveCwd} (${reason})`);
 			return currentResult;
 		}
 
@@ -302,7 +471,7 @@ export async function runSingleAgent(
 			currentResult.exitCode = 130;
 			currentResult.aborted = true;
 			currentResult.stopReason = "aborted";
-			currentResult.errorMessage = "Subagent was aborted before start";
+			setErrorMessage("Subagent was aborted before start");
 			return currentResult;
 		}
 
@@ -356,22 +525,37 @@ export async function runSingleAgent(
 					},
 				});
 			} catch (error) {
-				currentResult.errorMessage = error instanceof Error ? error.message : String(error);
-				currentResult.stderr = currentResult.errorMessage;
+				currentResult.stderr = setErrorMessage(
+					error instanceof Error ? error.message : String(error),
+				);
 				finish(1);
 				return;
 			}
 
-			let capturedMessageBytes = 0;
 			const addMessage = (msg: Message) => {
-				if (currentResult.messages.length >= DEFAULT_MAX_MESSAGES) {
+				const boundedMessage = boundMessageText(msg, DEFAULT_MAX_OUTPUT_BYTES - 2);
+				currentResult.truncated ||= boundedMessage.truncated;
+				if (!boundedMessage.message) return;
+				while (
+					currentResult.messages.length >= DEFAULT_MAX_MESSAGES ||
+					Buffer.byteLength(
+						JSON.stringify([...currentResult.messages, boundedMessage.message]),
+						"utf8",
+					) > DEFAULT_MAX_OUTPUT_BYTES
+				) {
+					const removed = currentResult.messages.shift();
+					if (!removed) break;
+					currentResult.truncated = true;
+				}
+				if (
+					Buffer.byteLength(
+						JSON.stringify([...currentResult.messages, boundedMessage.message]),
+						"utf8",
+					) > DEFAULT_MAX_OUTPUT_BYTES
+				) {
 					currentResult.truncated = true;
 					return;
 				}
-				const remaining = Math.max(0, DEFAULT_MAX_OUTPUT_BYTES - capturedMessageBytes);
-				const boundedMessage = boundMessageText(msg, remaining);
-				capturedMessageBytes += boundedMessage.bytes;
-				currentResult.truncated ||= boundedMessage.truncated;
 				currentResult.messages.push(boundedMessage.message);
 			};
 			const processEvent = (raw: unknown) => {
@@ -379,6 +563,15 @@ export async function runSingleAgent(
 				const event = raw as { type?: string; message?: Message };
 				if (event.type === "message_end" && event.message) {
 					const msg = event.message;
+					if (msg.role === "assistant") {
+						const output = truncateUtf8(getFinalOutput([msg]), DEFAULT_MAX_OUTPUT_BYTES);
+						currentResult.truncated ||= output.truncated;
+						if (output.text) latestAssistantOutput = output.text;
+						if (msg.stopReason === "stop" || msg.stopReason === "length") {
+							terminalAssistantOutput = output.text;
+						}
+					}
+					appendRecentActivity(currentResult, msg);
 					addMessage(msg);
 					if (msg.role === "assistant") {
 						currentResult.usage.turns++;
@@ -391,9 +584,11 @@ export async function runSingleAgent(
 							currentResult.usage.cost += usage.cost?.total || 0;
 							currentResult.usage.contextTokens = usage.totalTokens || 0;
 						}
-						if (!currentResult.model && msg.model) currentResult.model = msg.model;
+						if (msg.provider) currentResult.actualProvider = msg.provider;
+						if (msg.responseModel ?? msg.model)
+							currentResult.actualModel = msg.responseModel ?? msg.model;
 						if (msg.stopReason) currentResult.stopReason = msg.stopReason;
-						if (msg.errorMessage) currentResult.errorMessage = msg.errorMessage;
+						if (msg.errorMessage) setErrorMessage(msg.errorMessage);
 					}
 					emitUpdate();
 				} else if (event.type === "tool_result_end" && event.message) {
@@ -415,7 +610,7 @@ export async function runSingleAgent(
 				timedOut = true;
 				currentResult.timedOut = true;
 				currentResult.stopReason = "timeout";
-				currentResult.errorMessage = `Subagent timed out after ${timeoutMs}ms`;
+				setErrorMessage(`Subagent timed out after ${timeoutMs}ms`);
 				const bounded = appendBounded(
 					currentResult.stderr,
 					`\nSubagent timed out after ${timeoutMs}ms.`,
@@ -430,7 +625,11 @@ export async function runSingleAgent(
 
 			proc.stdout?.on("data", (data) => decoder.push(data));
 			proc.stderr?.on("data", (data) => {
-				const bounded = appendBounded(currentResult.stderr, data.toString(), DEFAULT_MAX_STDERR_BYTES);
+				const bounded = appendBounded(
+					currentResult.stderr,
+					data.toString(),
+					DEFAULT_MAX_STDERR_BYTES,
+				);
 				currentResult.stderr = bounded.text;
 				currentResult.truncated ||= bounded.truncated;
 			});
@@ -439,10 +638,10 @@ export async function runSingleAgent(
 				finish(timedOut ? 124 : wasAborted ? 130 : (code ?? 0));
 			});
 			proc.on("error", (error) => {
-				currentResult.errorMessage = error.message;
+				const message = setErrorMessage(error.message);
 				const bounded = appendBounded(
 					currentResult.stderr,
-					`${currentResult.stderr ? "\n" : ""}${error.message}`,
+					`${currentResult.stderr ? "\n" : ""}${message}`,
 					DEFAULT_MAX_STDERR_BYTES,
 				);
 				currentResult.stderr = bounded.text;
@@ -456,7 +655,7 @@ export async function runSingleAgent(
 					wasAborted = true;
 					currentResult.aborted = true;
 					currentResult.stopReason = "aborted";
-					currentResult.errorMessage = "Subagent was aborted";
+					setErrorMessage("Subagent was aborted");
 					cleanupTermination = terminateProcess(proc);
 				};
 				if (signal.aborted) abortHandler();
@@ -465,9 +664,18 @@ export async function runSingleAgent(
 		});
 
 		currentResult.exitCode = exitCode;
-		const final = truncateUtf8(getFinalOutput(currentResult.messages), DEFAULT_MAX_OUTPUT_BYTES);
+		const final = truncateUtf8(selectedAssistantOutput(), DEFAULT_MAX_OUTPUT_BYTES);
 		currentResult.finalOutput = final.text;
 		currentResult.truncated ||= final.truncated;
+		if (
+			currentResult.exitCode === 0 &&
+			currentResult.stopReason !== "error" &&
+			(currentResult.stopReason === "toolUse" || !currentResult.finalOutput.trim())
+		) {
+			currentResult.exitCode = 1;
+			currentResult.stopReason = "error";
+			setErrorMessage("Subagent completed without final text");
+		}
 		currentResult.policy = {
 			inherited: ["environment"],
 			overridden: [