@shanepadgett/tau-agent 0.42.3 → 0.44.0

package/extensions/subagent/run.ts

@@ -1,641 +0,0 @@
-import { createHash } from "node:crypto";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import type { AssistantMessage, Usage } from "@earendil-works/pi-ai";
-import {
-	DEFAULT_MAX_BYTES,
-	DEFAULT_MAX_LINES,
-	formatSize,
-	truncateHead,
-	type AgentSessionEvent,
-	type ExtensionAPI,
-	type ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { createCompleteFileMeta } from "../../shared/full-file-knowledge.ts";
-import { createIsolatedSessionResource, type IsolatedSessionResource } from "../../shared/isolated-session.ts";
-import { FILE_INJECTION_TYPE } from "@shanepadgett/tau-agent";
-import type { AgentDefinition } from "./agents.ts";
-import { emptySubagentResumeState, type RetainedTurnOutcome, type SubagentResumeState } from "./resume.ts";
-import { resolveSubagentSessionInputs, type SubagentSessionInputs } from "./session-resource.ts";
-
-const PREVIEW_LIMIT = 600;
-const VALUE_LIMIT = 180;
-
-export interface SubagentAction {
-	tool: string;
-	summary: string;
-	error: boolean;
-}
-export interface SubagentUsage {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	turns: number;
-}
-
-export type SubagentLifecycle = "waiting" | "starting" | "running" | "completed" | "failed" | "aborted";
-export type SubagentPhase = "discovery" | "queue" | "startup" | "run" | "output";
-
-export interface SubagentDetails {
-	agent: string;
-	displayName: string;
-	threadId?: string;
-	invocationId?: string;
-	status: SubagentLifecycle;
-	phase: SubagentPhase;
-	completionState?: string;
-	task: string;
-	model: string;
-	thinkingLevel: string;
-	response?: string;
-	error?: string;
-	currentActivity?: string;
-	toolCalls: number;
-	actions: SubagentAction[];
-	omittedActions: number;
-	omittedErrors: number;
-	usage: SubagentUsage;
-	contextPercent?: number;
-	durationMs: number;
-	truncation?: {
-		truncated: boolean;
-		path?: string;
-		outputLines: number;
-		totalLines: number;
-		outputBytes: number;
-		totalBytes: number;
-	};
-}
-
-/** Immutable observer payload. Distinct invocation IDs for queued turns of one thread. */
-export interface SubagentInvocationSnapshot extends SubagentDetails {
-	invocationId: string;
-	startedAt: number;
-	files: readonly string[];
-}
-
-export interface SubagentThread {
-	id: string;
-	displayName: string;
-	definition: AgentDefinition;
-	sessionInputs: SubagentSessionInputs;
-	resource: IsolatedSessionResource;
-	cwd: string;
-	model: string;
-	thinkingLevel: string;
-	initialTask: string;
-	resumeState: SubagentResumeState;
-	lastAssistantMessageAt: number | undefined;
-	turns: number;
-	turnGate: FifoGate;
-	pendingTurns: number;
-	lastUsedAt: number;
-}
-
-export function extensionPathsForTools(pi: ExtensionAPI, tools: readonly string[]): string[] {
-	const selected = new Set(tools);
-	return [
-		...new Set(
-			pi
-				.getAllTools()
-				.filter((tool) => selected.has(tool.name))
-				.map((tool) => tool.sourceInfo.path)
-				.filter((path) => path.length > 0 && !path.startsWith("<")),
-		),
-	].sort();
-}
-
-export class FifoGate {
-	private active = 0;
-	private readonly waiters: Array<{
-		signal: AbortSignal;
-		resolve: (release: () => void) => void;
-		reject: (error: Error) => void;
-	}> = [];
-	private readonly limit: number;
-	constructor(limit = 4) {
-		this.limit = limit;
-	}
-	acquire(signal: AbortSignal): Promise<() => void> {
-		if (signal.aborted) return Promise.reject(new Error("Subagent call aborted while waiting"));
-		if (this.active < this.limit) {
-			this.active += 1;
-			return Promise.resolve(this.releaseOnce());
-		}
-		return new Promise((resolve, reject) => {
-			const waiter = { signal, resolve: (_release: () => void) => {}, reject };
-			const abort = () => {
-				const index = this.waiters.indexOf(waiter);
-				if (index >= 0) this.waiters.splice(index, 1);
-				reject(new Error("Subagent call aborted while waiting"));
-			};
-			signal.addEventListener("abort", abort, { once: true });
-			waiter.resolve = (release) => {
-				signal.removeEventListener("abort", abort);
-				resolve(release);
-			};
-			this.waiters.push(waiter);
-		});
-	}
-	private releaseOnce(): () => void {
-		let released = false;
-		return () => {
-			if (released) return;
-			released = true;
-			const next = this.waiters.shift();
-			if (next) next.resolve(this.releaseOnce());
-			else this.active -= 1;
-		};
-	}
-}
-
-function capped(value: unknown, limit = VALUE_LIMIT): string {
-	let text: string;
-	try {
-		text = typeof value === "string" ? value : (JSON.stringify(value) ?? String(value));
-	} catch {
-		text = "[unavailable]";
-	}
-	return text.length <= limit ? text : `${text.slice(0, limit - 1)}…`;
-}
-
-/** Rolling tail so live previews keep changing after the limit. */
-function cappedTail(value: unknown, limit = PREVIEW_LIMIT): string {
-	let text: string;
-	try {
-		text = typeof value === "string" ? value : (JSON.stringify(value) ?? String(value));
-	} catch {
-		text = "[unavailable]";
-	}
-	if (text.length <= limit) return text;
-	return `…${text.slice(-(limit - 1))}`;
-}
-
-function textOf(message: AssistantMessage): string {
-	return message.content
-		.filter((part) => part.type === "text")
-		.map((part) => part.text)
-		.join("");
-}
-
-function cloneSnapshot(details: SubagentDetails): SubagentDetails {
-	return structuredClone(details);
-}
-
-export function cloneInvocationSnapshot(snapshot: SubagentInvocationSnapshot): SubagentInvocationSnapshot {
-	return structuredClone(snapshot);
-}
-
-export async function createSubagentThread(options: {
-	id: string;
-	displayName: string;
-	definition: AgentDefinition;
-	extensionPaths: readonly string[];
-	initialTask: string;
-	ctx: ExtensionContext;
-	thinkingLevel: NonNullable<ExtensionContext["thinkingLevel"]>;
-	signal: AbortSignal;
-	onWarning?: (warning: string) => void;
-}): Promise<SubagentThread> {
-	const {
-		id,
-		displayName,
-		definition,
-		extensionPaths,
-		initialTask,
-		ctx,
-		thinkingLevel: parentThinkingLevel,
-		signal,
-		onWarning,
-	} = options;
-	const sessionInputs = await resolveSubagentSessionInputs({
-		definition,
-		extensionPaths,
-		ctx,
-		parentThinkingLevel,
-		signal,
-		...(onWarning === undefined ? {} : { onWarning }),
-	});
-	const resource = await createIsolatedSessionResource(sessionInputs, signal);
-	try {
-		return {
-			id,
-			displayName,
-			definition,
-			sessionInputs,
-			resource,
-			cwd: ctx.cwd,
-			model: sessionInputs.modelName,
-			thinkingLevel: sessionInputs.thinkingLevel,
-			initialTask,
-			resumeState: emptySubagentResumeState(),
-			lastAssistantMessageAt: undefined,
-			turns: 0,
-			turnGate: new FifoGate(1),
-			pendingTurns: 0,
-			lastUsedAt: Date.now(),
-		};
-	} catch (error) {
-		await resource.dispose();
-		throw error;
-	}
-}
-
-export async function disposeSubagentThread(thread: SubagentThread): Promise<void> {
-	await thread.resource.dispose();
-}
-
-function emptyTurnUsage(): { usage: SubagentUsage; toolUsage: Usage } {
-	return {
-		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 },
-		toolUsage: {
-			input: 0,
-			output: 0,
-			cacheRead: 0,
-			cacheWrite: 0,
-			totalTokens: 0,
-			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-		},
-	};
-}
-
-function accumulateAssistantUsage(usage: SubagentUsage, toolUsage: Usage, message: AssistantMessage): void {
-	usage.input += message.usage.input;
-	usage.output += message.usage.output;
-	usage.cacheRead += message.usage.cacheRead;
-	usage.cacheWrite += message.usage.cacheWrite;
-	usage.cost += message.usage.cost.total;
-	usage.turns += 1;
-	toolUsage.input += message.usage.input;
-	toolUsage.output += message.usage.output;
-	toolUsage.cacheRead += message.usage.cacheRead;
-	toolUsage.cacheWrite += message.usage.cacheWrite;
-	toolUsage.totalTokens += message.usage.totalTokens;
-	toolUsage.cost.input += message.usage.cost.input;
-	toolUsage.cost.output += message.usage.cost.output;
-	toolUsage.cost.cacheRead += message.usage.cost.cacheRead;
-	toolUsage.cost.cacheWrite += message.usage.cost.cacheWrite;
-	toolUsage.cost.total += message.usage.cost.total;
-	if (message.usage.cacheWrite1h !== undefined)
-		toolUsage.cacheWrite1h = (toolUsage.cacheWrite1h ?? 0) + message.usage.cacheWrite1h;
-	if (message.usage.reasoning !== undefined)
-		toolUsage.reasoning = (toolUsage.reasoning ?? 0) + message.usage.reasoning;
-}
-
-function pushBoundedAction(details: SubagentDetails, action: SubagentAction): void {
-	details.actions.push(action);
-	if (details.actions.length <= 20) return;
-	const removable = details.actions.findIndex((item) => !item.error);
-	const [removed] = details.actions.splice(removable >= 0 ? removable : 0, 1);
-	details.omittedActions += 1;
-	if (removed?.error) details.omittedErrors += 1;
-}
-
-function subscribeTurnEvents(options: {
-	session: SubagentThread["resource"]["session"];
-	details: SubagentDetails;
-	usage: SubagentUsage;
-	toolUsage: Usage;
-	turnMessages: AssistantMessage[];
-	assistantMessageEndAt: number[];
-	publish: (force?: boolean) => void;
-}): () => void {
-	const { session, details, usage, toolUsage, turnMessages, assistantMessageEndAt, publish } = options;
-	const actionById = new Map<string, string>();
-	return session.subscribe((event: AgentSessionEvent) => {
-		if (event.type === "message_start" && event.message.role === "assistant") {
-			details.response = "";
-			return;
-		}
-		if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-			details.response = cappedTail(details.response + event.assistantMessageEvent.delta, PREVIEW_LIMIT);
-			publish();
-			return;
-		}
-		if (event.type === "message_end" && event.message.role === "assistant") {
-			turnMessages.push(event.message);
-			assistantMessageEndAt.push(Date.now());
-			accumulateAssistantUsage(usage, toolUsage, event.message);
-			details.response = cappedTail(textOf(event.message), PREVIEW_LIMIT);
-			details.currentActivity = undefined;
-			publish(true);
-			return;
-		}
-		if (event.type === "tool_execution_start") {
-			details.toolCalls += 1;
-			const summary = `${event.toolName} ${capped(event.args)}`.trim();
-			actionById.set(event.toolCallId, summary);
-			details.currentActivity = summary;
-			publish(true);
-			return;
-		}
-		if (event.type === "tool_execution_end") {
-			pushBoundedAction(details, {
-				tool: event.toolName,
-				summary: actionById.get(event.toolCallId) ?? event.toolName,
-				error: event.isError,
-			});
-			details.currentActivity = undefined;
-			publish(true);
-		}
-	});
-}
-
-async function buildAutoreadMessages(options: { files: readonly string[]; cwd: string; invocationId: string }): Promise<
-	Array<{
-		customType: typeof FILE_INJECTION_TYPE;
-		content: string;
-		display: false;
-		details: Record<string, unknown>;
-	}>
-> {
-	const { files, cwd, invocationId } = options;
-	return Promise.all(
-		files.map(async (file, index) => {
-			const pathKey = resolve(cwd, file);
-			const common = {
-				v: 1 as const,
-				rowId: `${invocationId}:${index}`,
-				path: file,
-				cwd,
-				source: "subagent",
-				batchId: invocationId,
-			};
-			try {
-				const bytes = await readFile(pathKey);
-				const content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-				const lines = content.split("\n");
-				const numbered = lines.map((line, lineIndex) => `${lineIndex + 1}: ${line}`).join("\n");
-				return {
-					customType: FILE_INJECTION_TYPE,
-					content: `${file}\n${numbered}`,
-					display: false as const,
-					details: {
-						...common,
-						kind: "full",
-						status: "injected",
-						readCache: createCompleteFileMeta({
-							pathKey,
-							presentation: "line-numbered",
-							servedHash: createHash("sha256").update(bytes).digest("hex"),
-							mode: "baseline",
-							sourceText: content,
-							returnedText: `${file}\n${numbered}`,
-							totalLines: lines.length,
-							summary: `${lines.length} lines`,
-						}),
-					},
-				};
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				return {
-					customType: FILE_INJECTION_TYPE,
-					content: `${file}\nInjection failed: ${message}`,
-					display: false as const,
-					details: { ...common, kind: "full", status: "failed", error: message },
-				};
-			}
-		}),
-	);
-}
-
-function buildTurnPrompt(options: {
-	definition: AgentDefinition;
-	task: string;
-	files: readonly string[];
-	initial: boolean;
-	resumePrompt: string | undefined;
-}): string {
-	const { definition, task, files, initial, resumePrompt } = options;
-	if (resumePrompt !== undefined) return resumePrompt;
-	const fileNote = files.length
-		? " Parent-supplied autoread files are included as line-numbered context for this turn."
-		: "";
-	if (initial) {
-		return `You are an isolated delegated child agent. Stay within the delegated task and return only the requested result.${fileNote}\n\n## Agent instructions\n${definition.prompt}\n\n## Delegated task\n${task}`;
-	}
-	return `Continue the existing delegated work using the context already in this thread. Return only the requested result.${fileNote}\n\n## Parent follow-up\n${task}`;
-}
-
-async function applyTerminalOutcome(
-	details: SubagentDetails,
-	terminal: AssistantMessage,
-	definitionName: string,
-): Promise<void> {
-	const response = textOf(terminal);
-	if (terminal.stopReason === "aborted") {
-		details.status = "aborted";
-		details.completionState = "aborted";
-		details.error = capped(terminal.errorMessage ?? "Child aborted");
-		return;
-	}
-	if (terminal.stopReason === "error") {
-		details.status = "failed";
-		details.completionState = "error";
-		details.error = capped(terminal.errorMessage ?? "Child terminal error");
-		return;
-	}
-	if ((terminal.stopReason === "stop" || terminal.stopReason === "length") && response.trim()) {
-		details.status = "completed";
-		details.completionState = terminal.stopReason;
-		details.phase = "output";
-		const truncation = truncateHead(response, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
-		let returned = truncation.content;
-		let path: string | undefined;
-		if (truncation.truncated) {
-			const directory = await mkdtemp(join(tmpdir(), "tau-subagent-"));
-			path = join(directory, "output.md");
-			await writeFile(path, response, { encoding: "utf8", mode: 0o600 });
-			returned += `\n\n[Output truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)}). Full output saved to: ${path}]`;
-		}
-		details.response = returned;
-		details.truncation = {
-			truncated: truncation.truncated,
-			path,
-			outputLines: truncation.outputLines,
-			totalLines: truncation.totalLines,
-			outputBytes: truncation.outputBytes,
-			totalBytes: truncation.totalBytes,
-		};
-		return;
-	}
-	details.status = "failed";
-	details.completionState = terminal.stopReason;
-	details.error = `Agent ${definitionName} run failed: empty or non-terminal response`;
-}
-
-async function deliverTurnPrompt(options: {
-	session: SubagentThread["resource"]["session"];
-	thread: SubagentThread;
-	task: string;
-	files: readonly string[];
-	invocationId: string;
-	initial: boolean;
-	resumePrompt: string | undefined;
-	signal: AbortSignal;
-}): Promise<void> {
-	const { session, thread, task, files, invocationId, initial, resumePrompt, signal } = options;
-	const abort = () => {
-		void session.abort().catch(() => undefined);
-	};
-	signal.addEventListener("abort", abort, { once: true });
-	try {
-		const autoreadMessages = await buildAutoreadMessages({
-			files,
-			cwd: thread.cwd,
-			invocationId,
-		});
-		if (signal.aborted) throw new Error("Subagent call aborted before prompt");
-		for (const message of autoreadMessages) {
-			if (signal.aborted) throw new Error("Subagent call aborted during autoread delivery");
-			await session.sendCustomMessage<unknown>(message, { deliverAs: "nextTurn" });
-		}
-		if (signal.aborted) throw new Error("Subagent call aborted before prompt");
-		await session.prompt(buildTurnPrompt({ definition: thread.definition, task, files, initial, resumePrompt }), {
-			expandPromptTemplates: false,
-		});
-	} finally {
-		signal.removeEventListener("abort", abort);
-	}
-}
-
-function turnResult(
-	details: SubagentDetails,
-	retainable: boolean,
-	assistantMessageEndAt: readonly number[],
-	usage: SubagentUsage,
-	toolUsage: Usage,
-	definitionName: string,
-): {
-	content: string;
-	details: SubagentDetails;
-	retainable: boolean;
-	terminalOutcome: RetainedTurnOutcome;
-	assistantMessageEndAt: readonly number[];
-	usage?: Usage;
-} {
-	return {
-		content:
-			details.status === "completed"
-				? (details.response ?? "")
-				: (details.error ?? `Agent ${definitionName} failed`),
-		details,
-		retainable,
-		terminalOutcome:
-			details.status === "completed" ? "completed" : details.status === "aborted" ? "aborted" : "failed",
-		assistantMessageEndAt,
-		...(usage.turns === 0 ? {} : { usage: toolUsage }),
-	};
-}
-
-export async function runSubagentTurn(options: {
-	thread: SubagentThread;
-	task: string;
-	files?: readonly string[];
-	invocationId?: string;
-	initial: boolean;
-	resumePrompt?: string;
-	signal: AbortSignal;
-	onUpdate?: (details: SubagentDetails) => void | Promise<void>;
-}): Promise<{
-	content: string;
-	details: SubagentDetails;
-	retainable: boolean;
-	terminalOutcome: RetainedTurnOutcome;
-	assistantMessageEndAt: readonly number[];
-	usage?: Usage;
-}> {
-	const { thread, task, files = [], invocationId = thread.id, initial, resumePrompt, signal, onUpdate } = options;
-	const { definition } = thread;
-	const { session } = thread.resource;
-	const started = Date.now();
-	const { usage, toolUsage } = emptyTurnUsage();
-	const details: SubagentDetails = {
-		agent: definition.name,
-		displayName: thread.displayName,
-		threadId: thread.id,
-		status: "running",
-		phase: "run",
-		task,
-		model: thread.model,
-		thinkingLevel: thread.thinkingLevel,
-		toolCalls: 0,
-		actions: [],
-		omittedActions: 0,
-		omittedErrors: 0,
-		usage,
-		durationMs: 0,
-	};
-	let unsubscribe: (() => void) | undefined;
-	let lastTextUpdate = 0;
-	const turnMessages: AssistantMessage[] = [];
-	const assistantMessageEndAt: number[] = [];
-	let retainable = false;
-	const publish = (force = false) => {
-		const now = Date.now();
-		if (!force && now - lastTextUpdate < 100) return;
-		lastTextUpdate = now;
-		details.durationMs = now - started;
-		const context = session.getContextUsage();
-		if (typeof context?.percent === "number") details.contextPercent = context.percent;
-		else delete details.contextPercent;
-		const snapshot = cloneSnapshot(details);
-		snapshot.actions = snapshot.actions.slice(-5);
-		// Detached observer chain — must not delay prompt completion.
-		void Promise.resolve()
-			.then(() => onUpdate?.(snapshot))
-			.catch(() => undefined);
-	};
-	try {
-		if (signal.aborted) {
-			details.status = "aborted";
-			details.error = "Subagent call aborted before prompt";
-			details.durationMs = Date.now() - started;
-			publish(true);
-			return turnResult(details, false, assistantMessageEndAt, usage, toolUsage, definition.name);
-		}
-		unsubscribe = subscribeTurnEvents({
-			session,
-			details,
-			usage,
-			toolUsage,
-			turnMessages,
-			assistantMessageEndAt,
-			publish,
-		});
-		await deliverTurnPrompt({
-			session,
-			thread,
-			task,
-			files,
-			invocationId,
-			initial,
-			resumePrompt,
-			signal,
-		});
-		// Prompt returned without throw — session remains usable for retention decisions.
-		retainable = true;
-		const terminal = turnMessages.at(-1);
-		if (!terminal) throw new Error(`Agent ${definition.name} run failed: no terminal assistant response`);
-		await applyTerminalOutcome(details, terminal, definition.name);
-		details.durationMs = Date.now() - started;
-		publish(true);
-		return turnResult(details, retainable, assistantMessageEndAt, usage, toolUsage, definition.name);
-	} catch (error) {
-		details.status = signal.aborted ? "aborted" : "failed";
-		details.error = capped(error instanceof Error ? error.message : "Subagent failed");
-		details.durationMs = Date.now() - started;
-		// Prompt/session failures leave the child unsafe for reuse.
-		retainable = false;
-		publish(true);
-		return turnResult(details, retainable, assistantMessageEndAt, usage, toolUsage, definition.name);
-	} finally {
-		unsubscribe?.();
-		thread.turns += 1;
-		thread.lastUsedAt = Date.now();
-		if (session.isStreaming) await session.abort().catch(() => undefined);
-	}
-}