@bacnh85/pi-subagent 0.3.1 → 0.5.0

package/extensions/model.ts

@@ -0,0 +1,86 @@
+/**
+ * Shared model resolution for pi-subagent.
+ *
+ * Provides a single canonical resolveModel() used by both the tool handler
+ * (index.ts) and the event-driven service path (service.ts), ensuring
+ * consistent error reporting across all sub-agent invocation paths.
+ *
+ * Queries the parent ModelRegistry first (catches custom-configured models
+ * with overridden base URLs, headers, compatibility settings). Falls back
+ * to the built-in registry for unconfigured models.
+ * For unqualified names (no provider prefix), known naming conventions
+ * are tried before assuming Anthropic.
+ */
+
+import { getModel } from "@earendil-works/pi-ai/compat";
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+
+export interface ResolvedModel {
+	model: Model<any> | null;
+	attempted: string[];
+}
+
+/** Known provider prefixes for unqualified model names. */
+const KNOWN_PROVIDERS: [string, RegExp][] = [
+	["openai", /^gpt-/i],
+	["anthropic", /^claude-/i],
+	["google", /^gemini-/i],
+	["cohere", /^command-/i],
+	["deepseek", /^(deepseek-|ds-)/i],
+	["mistral", /^mistral-/i],
+	["groq", /^(groq-|llama-)/i],
+];
+
+function tryGetModel(
+	provider: string,
+	id: string,
+	modelRegistry?: ModelRegistry,
+): Model<any> | null {
+	// Query parent ModelRegistry first — it includes custom-configured models
+	// (overridden base URLs, headers, compatibility settings, per-model overrides).
+	// Fall back to built-in registry for unconfigured models.
+	if (modelRegistry) {
+		const found = modelRegistry.find(provider as any, id as any) ?? null;
+		if (found) return found;
+	}
+	const builtIn = getModel(provider as any, id as any) ?? null;
+	if (builtIn) return builtIn;
+	return null;
+}
+
+export function resolveModel(
+	modelName: string | undefined,
+	parentModel: Model<any> | undefined,
+	modelRegistry?: ModelRegistry,
+): ResolvedModel {
+	const attempted: string[] = [];
+	if (modelName) {
+		const idx = modelName.indexOf("/");
+		if (idx > 0) {
+			// Provider-qualified: "openai/gpt-4o" or "openrouter/anthropic/claude-3.5"
+			const provider = modelName.slice(0, idx);
+			const id = modelName.slice(idx + 1);
+			attempted.push(modelName);
+			const found = tryGetModel(provider, id, modelRegistry);
+			if (found) return { model: found, attempted };
+		} else {
+			// Unqualified: try known providers by naming convention
+			for (const [provider, pattern] of KNOWN_PROVIDERS) {
+				if (pattern.test(modelName)) {
+					attempted.push(`${provider}/${modelName}`);
+					const found = tryGetModel(provider, modelName, modelRegistry);
+					if (found) return { model: found, attempted };
+				}
+			}
+			// Fall back to Anthropic shorthand (backward compat)
+			attempted.push(`anthropic/${modelName}`);
+			const found = tryGetModel("anthropic", modelName, modelRegistry);
+			if (found) return { model: found, attempted };
+		}
+	} else if (parentModel) {
+		attempted.push(`${parentModel.provider}/${parentModel.id}`);
+		return { model: parentModel, attempted };
+	}
+	return { model: null, attempted };
+}

package/extensions/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/{render.ts → extensions/render.ts}

@@ -1,5 +1,5 @@
 /**
- * TUI rendering for pi-sugagents.
+ * TUI rendering for pi-subagent.
  *
  * Renders sub-agent results in collapsed and expanded views.
  * Collapsed: status icon, agent name, last few items, usage stats.
@@ -12,6 +12,24 @@ import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import type { Message } from "@earendil-works/pi-ai";
 import { type SubAgentResult, isFailedResult, getResultOutput } from "./runner.ts";
 
+// ---------------------------------------------------------------------------
+// Safe type guards
+// ---------------------------------------------------------------------------
+
+function asString(value: unknown, fallback = "..."): string {
+	return typeof value === "string" ? value : fallback;
+}
+
+function asNumber(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" && !Array.isArray(value)
+		? (value as Record<string, unknown>)
+		: {};
+}
+
 // ---------------------------------------------------------------------------
 // Display helpers
 // ---------------------------------------------------------------------------
@@ -53,15 +71,15 @@ function formatToolCall(
 
 	switch (toolName) {
 		case "bash": {
-			const command = (args.command as string) || "...";
+			const command = asString(args.command);
 			const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
 			return themeFg("muted", "$ ") + themeFg("toolOutput", preview);
 		}
 		case "read": {
-			const rawPath = (args.file_path || args.path || "...") as string;
+			const rawPath = asString(args.file_path ?? args.path);
 			const filePath = shortenPath(rawPath);
-			const offset = args.offset as number | undefined;
-			const limit = args.limit as number | undefined;
+			const offset = asNumber(args.offset);
+			const limit = asNumber(args.limit);
 			let text = themeFg("accent", filePath);
 			if (offset !== undefined || limit !== undefined) {
 				const startLine = offset ?? 1;
@@ -71,24 +89,24 @@ function formatToolCall(
 			return themeFg("muted", "read ") + text;
 		}
 		case "write": {
-			const rawPath = (args.file_path || args.path || "...") as string;
-			const content = (args.content || "") as string;
+			const rawPath = asString(args.file_path ?? args.path);
+			const content = asString(args.content, "");
 			const lines = content.split("\n").length;
 			let text = themeFg("muted", "write ") + themeFg("accent", shortenPath(rawPath));
 			if (lines > 1) text += themeFg("dim", ` (${lines} lines)`);
 			return text;
 		}
 		case "edit": {
-			const rawPath = (args.file_path || args.path || "...") as string;
+			const rawPath = asString(args.file_path ?? args.path);
 			return themeFg("muted", "edit ") + themeFg("accent", shortenPath(rawPath));
 		}
 		case "ls": {
-			const rawPath = (args.path || ".") as string;
+			const rawPath = asString(args.path, ".");
 			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(rawPath));
 		}
 		case "find": {
-			const pattern = (args.pattern || "*") as string;
-			const rawPath = (args.path || ".") as string;
+			const pattern = asString(args.pattern, "*");
+			const rawPath = asString(args.path, ".");
 			return (
 				themeFg("muted", "find ") +
 				themeFg("accent", pattern) +
@@ -96,8 +114,8 @@ function formatToolCall(
 			);
 		}
 		case "grep": {
-			const pattern = (args.pattern || "") as string;
-			const rawPath = (args.path || ".") as string;
+			const pattern = asString(args.pattern);
+			const rawPath = asString(args.path, ".");
 			return (
 				themeFg("muted", "grep ") +
 				themeFg("accent", `/${pattern}/`) +
@@ -127,7 +145,7 @@ function getDisplayItems(messages: Message[]): DisplayItem[] {
 					items.push({
 						type: "toolCall",
 						name: part.name,
-						args: part.arguments as Record<string, unknown>,
+						args: asRecord(part.arguments),
 					});
 				}
 			}
@@ -169,7 +187,7 @@ function renderDisplayItems(
 export function renderSingleResult(
 	result: SubAgentResult,
 	expanded: boolean,
-	theme: { fg: (c: string, t: string) => string; bold: (t: string) => string },
+	theme: { fg: (c: any, t: string) => string; bold: (t: string) => string },
 ): Container | Text {
 	const isError = isFailedResult(result);
 	const icon = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");

package/{runner.ts → extensions/runner.ts}

@@ -1,5 +1,5 @@
 /**
- * SDK-based sub-agent runner for pi-sugagents.
+ * SDK-based sub-agent runner for pi-subagent.
  *
  * Creates an in-process AgentSession via the pi SDK instead of spawning a
  * separate `pi` process. This eliminates cold-start overhead and allows
@@ -61,12 +61,14 @@ export async function runSubAgent(options: {
 	systemPrompt: string;
 	task: string;
 	tools: string[];
-	model: Model;
+	model: Model<any>;
 	authStorage: AuthStorage;
 	modelRegistry: ModelRegistry;
 	signal?: AbortSignal;
 	agentName?: string;
+	thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
 	onUpdate?: (text: string) => void;
+	onMessage?: (partialResult: SubAgentResult) => void;
 }): Promise<SubAgentResult> {
 	const {
 		cwd,
@@ -78,7 +80,9 @@ export async function runSubAgent(options: {
 		modelRegistry,
 		signal,
 		agentName = "subagent",
+		thinkingLevel = "off",
 		onUpdate,
+		onMessage,
 	} = options;
 
 	const result: SubAgentResult = {
@@ -111,10 +115,17 @@ export async function runSubAgent(options: {
 	});
 
 	try {
+		if (signal?.aborted) {
+			result.exitCode = 1;
+			result.stopReason = "aborted";
+			result.errorMessage = "Sub-agent aborted before start";
+			return result;
+		}
+
 		const { session } = await createAgentSession({
 			cwd,
 			model,
-			thinkingLevel: "off", // no reasoning token overhead
+			thinkingLevel,
 			authStorage,
 			modelRegistry,
 			resourceLoader,
@@ -124,6 +135,7 @@ export async function runSubAgent(options: {
 		});
 
 		let cleanupAbort: (() => void) | undefined;
+		let cleanupEventAbort: (() => void) | undefined;
 		try {
 			// Wire abort signal
 			if (signal) {
@@ -142,6 +154,13 @@ export async function runSubAgent(options: {
 
 			// Collect all messages and usage stats from events
 			const eventPromise = new Promise<void>((resolve, reject) => {
+				let settled = false;
+				const finish = (fn: () => void) => {
+					if (settled) return;
+					settled = true;
+					fn();
+				};
+
 				const unsubscribe = session.subscribe((event) => {
 					try {
 						switch (event.type) {
@@ -165,6 +184,7 @@ export async function runSubAgent(options: {
 								}
 								// Collect all messages for extraction
 								result.messages.push(msg as unknown as Message);
+								if (onMessage) onMessage({ ...result, messages: [...result.messages] });
 								break;
 							}
 							case "agent_end": {
@@ -172,25 +192,49 @@ export async function runSubAgent(options: {
 								if (result.messages.length === 0 && event.messages) {
 									result.messages = event.messages as unknown as Message[];
 								}
-								unsubscribe();
-								resolve();
+								finish(() => {
+									unsubscribe();
+									resolve();
+								});
 								break;
 							}
 						}
 					} catch (err) {
-						unsubscribe();
-						reject(err);
+						finish(() => {
+							unsubscribe();
+							reject(err);
+						});
 					}
 				});
+
+				// Resolve on abort so the eventPromise doesn't hang
+				if (signal) {
+					const onAbortResolve = () => {
+						finish(() => {
+							result.exitCode = 1;
+							result.stopReason = "aborted";
+							if (!result.errorMessage) result.errorMessage = "Sub-agent aborted";
+							unsubscribe();
+							resolve();
+						});
+					};
+					signal.addEventListener("abort", onAbortResolve, { once: true });
+					cleanupEventAbort = () => signal.removeEventListener("abort", onAbortResolve);
+				}
 			});
 
-			await session.prompt(task);
-			await eventPromise;
+			await Promise.race([
+				session.prompt(task),
+				eventPromise,
+			]);
 
-			result.exitCode = 0;
+			if (result.stopReason !== "aborted") {
+				result.exitCode = 0;
+			}
 			return result;
 		} finally {
 			cleanupAbort?.();
+			cleanupEventAbort?.();
 			try {
 				session.dispose();
 			} catch {

package/extensions/service.ts

@@ -0,0 +1,79 @@
+import { AuthStorage, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { AgentConfig } from "./agents.ts";
+import { runSubAgent, type SubAgentResult } from "./runner.ts";
+import { resolveModel } from "./model.ts";
+
+export const SUBAGENT_REQUEST_EVENT = "pi-subagent:run";
+
+export interface SubagentRunRequest {
+	id: string;
+	agent: string;
+	task: string;
+	cwd?: string;
+	timeout?: number;
+	instructions?: string;
+	readOnly?: boolean;
+	signal?: AbortSignal;
+	accept?: () => boolean;
+	respond: (response: SubagentRunResponse) => void;
+}
+
+export type SubagentRunResponse =
+	| { id: string; ok: true; result: SubAgentResult }
+	| { id: string; ok: false; error: string };
+
+export async function runNamedAgent(options: {
+	agent: AgentConfig;
+	task: string;
+	cwd: string;
+	ctx: ExtensionContext;
+	timeout?: number;
+	instructions?: string;
+	signal?: AbortSignal;
+	onMessage?: (result: SubAgentResult) => void;
+}): Promise<SubAgentResult> {
+	const { model, attempted } = resolveModel(options.agent.model, options.ctx.model, options.ctx.modelRegistry);
+	if (!model) throw new Error(`No model resolved for agent "${options.agent.name}" (tried: ${attempted.join(", ") || "none"})`);
+
+	const authStorage = AuthStorage.inMemory();
+	const modelRegistry = options.ctx.modelRegistry;
+	const auth = await options.ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (auth.ok) {
+		if (auth.apiKey) authStorage.setRuntimeApiKey(model.provider, auth.apiKey);
+		// ponytail: env and headers stay on the parent modelRegistry — reuse it directly.
+	}
+
+	const timeoutController = options.timeout && options.timeout > 0 ? new AbortController() : undefined;
+	const timeoutId = timeoutController ? setTimeout(() => timeoutController.abort(), options.timeout) : undefined;
+	const signals = [options.signal, timeoutController?.signal].filter((value): value is AbortSignal => Boolean(value));
+	const signal = signals.length > 1
+		? typeof (AbortSignal as any).any === "function"
+			? (AbortSignal as any).any(signals)
+			: signals[0]
+		: signals[0];
+	const contract = options.instructions?.slice(0, 16 * 1024);
+
+	try {
+		const result = await runSubAgent({
+			cwd: options.cwd,
+			systemPrompt: contract ? `${options.agent.systemPrompt}\n\n## Task Contract\n${contract}` : options.agent.systemPrompt,
+			task: options.task,
+			tools: (options.agent.tools ?? ["read", "bash", "edit", "write", "grep", "find", "ls"]).filter((tool) => tool !== "subagent"),
+			model,
+			authStorage,
+			modelRegistry,
+			signal,
+			agentName: options.agent.name,
+			thinkingLevel: options.agent.thinking,
+			onMessage: options.onMessage,
+		});
+		if (timeoutController?.signal.aborted && !options.signal?.aborted) {
+			result.exitCode = 1;
+			result.stopReason = "timeout";
+			result.errorMessage ||= `Timeout after ${options.timeout}ms`;
+		}
+		return result;
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}