@oh-my-pi/pi-coding-agent 1.341.0 → 2.0.1337

package/src/core/tools/task/model-resolver.ts

@@ -1,13 +1,14 @@
 /**
  * Model resolution with fuzzy pattern matching.
  *
+ * Returns models in "provider/modelId" format for use with --model flag.
+ *
  * Supports:
- *   - Exact match: "claude-opus-4-5"
- *   - Fuzzy match: "opus" → "claude-opus-4-5"
+ *   - Exact match: "gpt-5.2" → "p-openai/gpt-5.2"
+ *   - Fuzzy match: "opus" → "p-anthropic/claude-opus-4-5"
  *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
  *   - "default" → undefined (use system default)
- *   - "pi/default" → configured default model from settings
- *   - "pi/smol" → configured smol model from settings
+ *   - "pi/slow" → configured slow model from settings
  */
 
 import { spawnSync } from "node:child_process";
@@ -21,7 +22,7 @@ const PI_CMD = process.platform === "win32" ? "pi.cmd" : "pi";
 /** Windows shell option for spawn/spawnSync */
 const PI_SHELL_OPT = process.platform === "win32";
 
-/** Cache for available models */
+/** Cache for available models (provider/modelId format) */
 let cachedModels: string[] | null = null;
 
 /** Cache expiry time (5 minutes) */
@@ -31,6 +32,7 @@ const CACHE_TTL_MS = 5 * 60 * 1000;
 
 /**
  * Get available models from `pi --list-models`.
+ * Returns models in "provider/modelId" format.
  * Caches the result for performance.
  */
 export function getAvailableModels(): string[] {
@@ -52,13 +54,14 @@ export function getAvailableModels(): string[] {
 			return cachedModels;
 		}
 
-		// Parse output: skip header line, extract model column
+		// Parse output: skip header line, extract provider/model
 		const lines = result.stdout.trim().split("\n");
 		cachedModels = lines
 			.slice(1) // Skip header
 			.map((line) => {
 				const parts = line.trim().split(/\s+/);
-				return parts[1]; // Model name is second column
+				// Format: provider/modelId
+				return parts[0] && parts[1] ? `${parts[0]}/${parts[1]}` : "";
 			})
 			.filter(Boolean);
 
@@ -106,23 +109,26 @@ function resolvePiAlias(role: string, availableModels: string[]): string | undef
 	const configured = roles[role] || roles[role.toLowerCase()];
 	if (!configured) return undefined;
 
-	// configured is in "provider/modelId" format, extract just the modelId for matching
-	const slashIdx = configured.indexOf("/");
-	if (slashIdx <= 0) return undefined;
+	// configured is in "provider/modelId" format, find in available models
+	return availableModels.find((m) => m.toLowerCase() === configured.toLowerCase());
+}
 
-	const modelId = configured.slice(slashIdx + 1);
-	// Find in available models
-	return availableModels.find((m) => m.toLowerCase() === modelId.toLowerCase());
+/**
+ * Extract model ID from "provider/modelId" format.
+ */
+function getModelId(fullModel: string): string {
+	const slashIdx = fullModel.indexOf("/");
+	return slashIdx > 0 ? fullModel.slice(slashIdx + 1) : fullModel;
 }
 
 /**
- * Resolve a fuzzy model pattern to an actual model name.
+ * Resolve a fuzzy model pattern to "provider/modelId" format.
  *
  * Supports comma-separated patterns (e.g., "gpt, opus") - tries each in order.
  * Returns undefined if pattern is "default", undefined, or no match found.
  *
  * @param pattern - Model pattern to resolve
- * @param availableModels - Optional pre-fetched list of available models
+ * @param availableModels - Optional pre-fetched list of available models (in provider/modelId format)
  */
 export function resolveModelPattern(pattern: string | undefined, availableModels?: string[]): string | undefined {
 	if (!pattern || pattern === "default") {
@@ -150,12 +156,16 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 			continue; // Role not configured, try next pattern
 		}
 
-		// Try exact match first
-		const exactMatch = models.find((m) => m.toLowerCase() === p.toLowerCase());
-		if (exactMatch) return exactMatch;
+		// Try exact match on full provider/modelId
+		const exactFull = models.find((m) => m.toLowerCase() === p.toLowerCase());
+		if (exactFull) return exactFull;
+
+		// Try exact match on model ID only
+		const exactId = models.find((m) => getModelId(m).toLowerCase() === p.toLowerCase());
+		if (exactId) return exactId;
 
-		// Try fuzzy match (substring)
-		const fuzzyMatch = models.find((m) => m.toLowerCase().includes(p.toLowerCase()));
+		// Try fuzzy match on model ID (substring)
+		const fuzzyMatch = models.find((m) => getModelId(m).toLowerCase().includes(p.toLowerCase()));
 		if (fuzzyMatch) return fuzzyMatch;
 	}
 

package/src/core/tools/task/parallel.ts

@@ -2,7 +2,7 @@
  * Parallel execution with concurrency control.
  */
 
-import { MAX_CONCURRENCY } from "./types.js";
+import { MAX_CONCURRENCY } from "./types";
 
 /**
  * Execute items with a concurrency limit using a worker pool pattern.

package/src/core/tools/task/render.ts

@@ -7,10 +7,20 @@
 
 import path from "node:path";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { Text } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../../modes/interactive/theme/theme.js";
-import type { RenderResultOptions } from "../../custom-tools/types.js";
-import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types.js";
+import { Container, Text } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+import type { RenderResultOptions } from "../../custom-tools/types";
+import type { ReportFindingDetails, SubmitReviewDetails } from "../review";
+import { subprocessToolRegistry } from "./subprocess-tool-registry";
+import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
+
+/** Priority labels for review findings */
+const PRIORITY_LABELS: Record<number, string> = {
+	0: "P0",
+	1: "P1",
+	2: "P2",
+	3: "P3",
+};
 
 /**
  * Format token count for display (e.g., 1.5k, 25k).
@@ -52,6 +62,8 @@ function getStatusIcon(status: AgentProgress["status"]): string {
 			return "✓";
 		case "failed":
 			return "✗";
+		case "aborted":
+			return "⊘";
 	}
 }
 
@@ -82,10 +94,16 @@ function renderAgentProgress(progress: AgentProgress, isLast: boolean, expanded:
 	const continuePrefix = isLast ? "   " : "│  ";
 
 	const icon = getStatusIcon(progress.status);
-	const iconColor = progress.status === "completed" ? "success" : progress.status === "failed" ? "error" : "accent";
+	const iconColor =
+		progress.status === "completed"
+			? "success"
+			: progress.status === "failed" || progress.status === "aborted"
+				? "error"
+				: "accent";
 
-	// Main status line
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", progress.agent)}`;
+	// Main status line - include index for Output tool ID derivation
+	const agentId = `${progress.agent}(${progress.index})`;
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)}`;
 
 	if (progress.status === "running") {
 		const taskPreview = truncate(progress.task, 40);
@@ -98,6 +116,8 @@ function renderAgentProgress(progress: AgentProgress, isLast: boolean, expanded:
 		statusLine += `: ${theme.fg("success", "done")}`;
 		statusLine += ` · ${theme.fg("dim", `${progress.toolCount} tools`)}`;
 		statusLine += ` · ${theme.fg("dim", `${formatTokens(progress.tokens)} tokens`)}`;
+	} else if (progress.status === "aborted") {
+		statusLine += `: ${theme.fg("error", "aborted")}`;
 	} else if (progress.status === "failed") {
 		statusLine += `: ${theme.fg("error", "failed")}`;
 	}
@@ -119,6 +139,26 @@ function renderAgentProgress(progress: AgentProgress, isLast: boolean, expanded:
 		lines.push(toolLine);
 	}
 
+	// Render extracted tool data inline (e.g., review findings)
+	if (progress.extractedToolData) {
+		for (const [toolName, dataArray] of Object.entries(progress.extractedToolData)) {
+			const handler = subprocessToolRegistry.getHandler(toolName);
+			if (handler?.renderInline) {
+				// Show last few items inline
+				const recentData = (dataArray as unknown[]).slice(-3);
+				for (const data of recentData) {
+					const component = handler.renderInline(data, theme);
+					if (component instanceof Text) {
+						lines.push(`${continuePrefix}${component.getText()}`);
+					}
+				}
+				if (dataArray.length > 3) {
+					lines.push(`${continuePrefix}${theme.fg("dim", `... ${dataArray.length - 3} more`)}`);
+				}
+			}
+		}
+	}
+
 	// Expanded view: recent output and tools
 	if (expanded && progress.status === "running") {
 		// Recent output
@@ -130,6 +170,93 @@ function renderAgentProgress(progress: AgentProgress, isLast: boolean, expanded:
 	return lines;
 }
 
+/**
+ * Render review result with combined verdict + findings in tree structure.
+ */
+function renderReviewResult(
+	summary: SubmitReviewDetails,
+	findings: ReportFindingDetails[],
+	continuePrefix: string,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	const lines: string[] = [];
+
+	// Verdict line
+	const verdictColor = summary.overall_correctness === "correct" ? "success" : "error";
+	const verdictIcon = summary.overall_correctness === "correct" ? "✓" : "✗";
+	lines.push(
+		`${continuePrefix}${theme.fg(verdictColor, verdictIcon)} Patch is ${theme.fg(verdictColor, summary.overall_correctness)} ${theme.fg("dim", `(${(summary.confidence * 100).toFixed(0)}% confidence)`)}`,
+	);
+
+	// Explanation preview (first ~80 chars when collapsed, full when expanded)
+	if (summary.explanation) {
+		if (expanded) {
+			// Full explanation, wrapped
+			const explanationLines = summary.explanation.split("\n");
+			for (const line of explanationLines) {
+				lines.push(`${continuePrefix}${theme.fg("dim", line)}`);
+			}
+		} else {
+			// Preview: first sentence or ~100 chars
+			const preview = truncate(`${summary.explanation.split(/[.!?]/)[0]}.`, 100);
+			lines.push(`${continuePrefix}${theme.fg("dim", preview)}`);
+		}
+	}
+
+	// Findings in tree structure
+	if (findings.length > 0) {
+		lines.push(`${continuePrefix}`); // Spacing
+		lines.push(...renderFindings(findings, continuePrefix, expanded, theme));
+	}
+
+	return lines;
+}
+
+/**
+ * Render review findings list (used with and without submit_review).
+ */
+function renderFindings(
+	findings: ReportFindingDetails[],
+	continuePrefix: string,
+	expanded: boolean,
+	theme: Theme,
+): string[] {
+	const lines: string[] = [];
+	const displayCount = expanded ? findings.length : Math.min(3, findings.length);
+
+	for (let i = 0; i < displayCount; i++) {
+		const finding = findings[i];
+		const isLastFinding = i === displayCount - 1 && (expanded || findings.length <= 3);
+		const findingPrefix = isLastFinding ? "└─" : "├─";
+		const findingContinue = isLastFinding ? "   " : "│  ";
+
+		const priority = PRIORITY_LABELS[finding.priority] ?? "P?";
+		const color = finding.priority === 0 ? "error" : finding.priority === 1 ? "warning" : "muted";
+		const titleText = finding.title.replace(/^\[P\d\]\s*/, "");
+		const loc = `${path.basename(finding.file_path)}:${finding.line_start}`;
+
+		lines.push(
+			`${continuePrefix}${findingPrefix} ${theme.fg(color, `[${priority}]`)} ${titleText} ${theme.fg("dim", loc)}`,
+		);
+
+		// Show body when expanded
+		if (expanded && finding.body) {
+			// Wrap body text
+			const bodyLines = finding.body.split("\n");
+			for (const bodyLine of bodyLines) {
+				lines.push(`${continuePrefix}${findingContinue}${theme.fg("dim", bodyLine)}`);
+			}
+		}
+	}
+
+	if (!expanded && findings.length > 3) {
+		lines.push(`${continuePrefix}${theme.fg("dim", `... ${findings.length - 3} more findings`)}`);
+	}
+
+	return lines;
+}
+
 /**
  * Render final result for a single agent.
  */
@@ -138,14 +265,19 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 	const prefix = isLast ? "└─" : "├─";
 	const continuePrefix = isLast ? "   " : "│  ";
 
-	const success = result.exitCode === 0;
-	const icon = success ? "✓" : "✗";
+	const aborted = result.aborted ?? false;
+	const success = !aborted && result.exitCode === 0;
+	const icon = aborted ? "⊘" : success ? "✓" : "✗";
 	const iconColor = success ? "success" : "error";
-
-	// Main status line
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", result.agent)}`;
-	statusLine += `: ${theme.fg(iconColor, success ? "done" : "failed")}`;
-	statusLine += ` · ${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
+	const statusText = aborted ? "aborted" : success ? "done" : "failed";
+
+	// Main status line - include index for Output tool ID derivation
+	const agentId = `${result.agent}(${result.index})`;
+	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", agentId)}`;
+	statusLine += `: ${theme.fg(iconColor, statusText)}`;
+	if (result.tokens > 0) {
+		statusLine += ` · ${theme.fg("dim", `${formatTokens(result.tokens)} tokens`)}`;
+	}
 	statusLine += ` · ${theme.fg("dim", formatDuration(result.durationMs))}`;
 
 	if (result.truncated) {
@@ -154,16 +286,69 @@ function renderAgentResult(result: SingleResult, isLast: boolean, expanded: bool
 
 	lines.push(statusLine);
 
-	// Output preview
-	const outputLines = result.output.split("\n").filter((l) => l.trim());
-	const previewCount = expanded ? 8 : 3;
+	// Check for review result (submit_review + report_finding)
+	const submitReviewData = result.extractedToolData?.submit_review as SubmitReviewDetails[] | undefined;
+	const reportFindingData = result.extractedToolData?.report_finding as ReportFindingDetails[] | undefined;
+
+	if (submitReviewData && submitReviewData.length > 0) {
+		// Use combined review renderer
+		const summary = submitReviewData[submitReviewData.length - 1];
+		const findings = reportFindingData ?? [];
+		lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
+		return lines;
+	}
+	if (reportFindingData && reportFindingData.length > 0) {
+		lines.push(
+			`${continuePrefix}${theme.fg("warning", "!")} ${theme.fg("dim", "Review summary missing (submit_review not called)")}`,
+		);
+		lines.push(`${continuePrefix}`); // Spacing
+		lines.push(...renderFindings(reportFindingData, continuePrefix, expanded, theme));
+		return lines;
+	}
 
-	for (const line of outputLines.slice(0, previewCount)) {
-		lines.push(`${continuePrefix}${theme.fg("dim", truncate(line, 70))}`);
+	// Check for extracted tool data with custom renderers (skip review tools)
+	let hasCustomRendering = false;
+	if (result.extractedToolData) {
+		for (const [toolName, dataArray] of Object.entries(result.extractedToolData)) {
+			// Skip review tools - handled above
+			if (toolName === "submit_review" || toolName === "report_finding") continue;
+
+			const handler = subprocessToolRegistry.getHandler(toolName);
+			if (handler?.renderFinal && (dataArray as unknown[]).length > 0) {
+				hasCustomRendering = true;
+				const component = handler.renderFinal(dataArray as unknown[], theme, expanded);
+				if (component instanceof Text) {
+					// Prefix each line with continuePrefix
+					const text = component.getText();
+					for (const line of text.split("\n")) {
+						if (line.trim()) {
+							lines.push(`${continuePrefix}${line}`);
+						}
+					}
+				} else if (component instanceof Container) {
+					// For containers, render each child
+					for (const child of (component as Container).children) {
+						if (child instanceof Text) {
+							lines.push(`${continuePrefix}${child.getText()}`);
+						}
+					}
+				}
+			}
+		}
 	}
 
-	if (outputLines.length > previewCount) {
-		lines.push(`${continuePrefix}${theme.fg("dim", `... ${outputLines.length - previewCount} more lines`)}`);
+	// Fallback to output preview if no custom rendering
+	if (!hasCustomRendering) {
+		const outputLines = result.output.split("\n").filter((l) => l.trim());
+		const previewCount = expanded ? 8 : 3;
+
+		for (const line of outputLines.slice(0, previewCount)) {
+			lines.push(`${continuePrefix}${theme.fg("dim", truncate(line, 70))}`);
+		}
+
+		if (outputLines.length > previewCount) {
+			lines.push(`${continuePrefix}${theme.fg("dim", `... ${outputLines.length - previewCount} more lines`)}`);
+		}
 	}
 
 	// Error message
@@ -207,21 +392,25 @@ export function renderResult(
 		});
 
 		// Summary line
-		const successCount = details.results.filter((r) => r.exitCode === 0).length;
-		const failCount = details.results.length - successCount;
+		const abortedCount = details.results.filter((r) => r.aborted).length;
+		const successCount = details.results.filter((r) => !r.aborted && r.exitCode === 0).length;
+		const failCount = details.results.length - successCount - abortedCount;
 		let summary = `\n${theme.fg("dim", "Total:")} `;
-		summary += theme.fg("success", `${successCount} succeeded`);
+		if (abortedCount > 0) {
+			summary += theme.fg("error", `${abortedCount} aborted`);
+			if (successCount > 0 || failCount > 0) summary += ", ";
+		}
+		if (successCount > 0) {
+			summary += theme.fg("success", `${successCount} succeeded`);
+			if (failCount > 0) summary += ", ";
+		}
 		if (failCount > 0) {
-			summary += `, ${theme.fg("error", `${failCount} failed`)}`;
+			summary += theme.fg("error", `${failCount} failed`);
 		}
 		summary += ` · ${theme.fg("dim", formatDuration(details.totalDurationMs))}`;
 		lines.push(summary);
 
-		// Artifacts location
-		if (details.outputPaths && details.outputPaths.length > 0) {
-			const artifactsDir = path.dirname(details.outputPaths[0]);
-			lines.push(`${theme.fg("dim", "Artifacts:")} ${theme.fg("muted", artifactsDir)}`);
-		}
+		// Artifacts suppressed from user view - available via session file
 	}
 
 	if (lines.length === 0) {

package/src/core/tools/task/subprocess-tool-registry.ts

@@ -0,0 +1,89 @@
+/**
+ * Registry for handling tool events from subprocess agents.
+ *
+ * Tools can register handlers to:
+ * - Extract structured data from their execution results
+ * - Trigger subprocess termination on completion
+ * - Provide custom rendering for realtime/final display
+ */
+
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { Theme } from "../../../modes/interactive/theme/theme";
+
+/** Event from subprocess tool execution (parsed from JSONL) */
+export interface SubprocessToolEvent {
+	toolName: string;
+	toolCallId: string;
+	args?: Record<string, unknown>;
+	result?: {
+		content: Array<{ type: string; text?: string }>;
+		details?: unknown;
+	};
+	isError?: boolean;
+}
+
+/** Handler for subprocess tool events */
+export interface SubprocessToolHandler<TData = unknown> {
+	/**
+	 * Extract structured data from tool result.
+	 * Extracted data is accumulated in progress.extractedToolData[toolName][].
+	 */
+	extractData?: (event: SubprocessToolEvent) => TData | undefined;
+
+	/**
+	 * Whether this tool's completion should terminate the subprocess.
+	 * Return true to send SIGTERM after the tool completes.
+	 */
+	shouldTerminate?: (event: SubprocessToolEvent) => boolean;
+
+	/**
+	 * Render a single data item inline during streaming progress.
+	 * Called for each tool execution end event.
+	 */
+	renderInline?: (data: TData, theme: Theme) => Component;
+
+	/**
+	 * Render accumulated data in the final result view.
+	 * Called once with all accumulated data for this tool.
+	 */
+	renderFinal?: (allData: TData[], theme: Theme, expanded: boolean) => Component;
+}
+
+/** Registry for subprocess tool handlers */
+class SubprocessToolRegistryImpl {
+	private handlers = new Map<string, SubprocessToolHandler>();
+
+	/**
+	 * Register a handler for a tool's subprocess events.
+	 */
+	register<T>(toolName: string, handler: SubprocessToolHandler<T>): void {
+		this.handlers.set(toolName, handler as SubprocessToolHandler);
+	}
+
+	/**
+	 * Get the handler for a tool, if registered.
+	 */
+	getHandler(toolName: string): SubprocessToolHandler | undefined {
+		return this.handlers.get(toolName);
+	}
+
+	/**
+	 * Check if a tool has a registered handler.
+	 */
+	hasHandler(toolName: string): boolean {
+		return this.handlers.has(toolName);
+	}
+
+	/**
+	 * Get all registered tool names.
+	 */
+	getRegisteredTools(): string[] {
+		return Array.from(this.handlers.keys());
+	}
+}
+
+/** Singleton registry instance */
+export const subprocessToolRegistry = new SubprocessToolRegistryImpl();
+
+/** Type helper for extracted tool data in progress/result */
+export type ExtractedToolData = Record<string, unknown[]>;

package/src/core/tools/task/types.ts

@@ -27,9 +27,12 @@ export const MAX_OUTPUT_LINES = 5000;
 /** Maximum agents to show in description */
 export const MAX_AGENTS_IN_DESCRIPTION = 10;
 
-/** Environment variable to inhibit subagent spawning */
+/** Environment variable to inhibit subagent spawning (legacy, still checked for backwards compat) */
 export const PI_NO_SUBAGENTS_ENV = "PI_NO_SUBAGENTS";
 
+/** Environment variable containing blocked agent name (self-recursion prevention) */
+export const PI_BLOCKED_AGENT_ENV = "PI_BLOCKED_AGENT";
+
 /** Task tool parameters */
 export const taskSchema = Type.Object({
 	context: Type.Optional(Type.String({ description: "Shared context prepended to all task prompts" })),
@@ -41,6 +44,30 @@ export const taskSchema = Type.Object({
 
 export type TaskParams = Static<typeof taskSchema>;
 
+/** A code review finding reported by the reviewer agent */
+export interface ReviewFinding {
+	title: string;
+	body: string;
+	priority: number;
+	confidence: number;
+	file_path: string;
+	line_start: number;
+	line_end: number;
+}
+
+/** Review summary submitted by the reviewer agent */
+export interface ReviewSummary {
+	overall_correctness: "correct" | "incorrect";
+	explanation: string;
+	confidence: number;
+}
+
+/** Structured review data extracted from reviewer agent */
+export interface ReviewData {
+	findings: ReviewFinding[];
+	summary?: ReviewSummary;
+}
+
 /** Agent definition (bundled or discovered) */
 export interface AgentDefinition {
 	name: string;
@@ -58,7 +85,7 @@ export interface AgentProgress {
 	index: number;
 	agent: string;
 	agentSource: AgentSource;
-	status: "pending" | "running" | "completed" | "failed";
+	status: "pending" | "running" | "completed" | "failed" | "aborted";
 	task: string;
 	currentTool?: string;
 	currentToolArgs?: string;
@@ -69,6 +96,8 @@ export interface AgentProgress {
 	tokens: number;
 	durationMs: number;
 	modelOverride?: string;
+	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
+	extractedToolData?: Record<string, unknown[]>;
 }
 
 /** Result from a single agent execution */
@@ -85,8 +114,13 @@ export interface SingleResult {
 	tokens: number;
 	modelOverride?: string;
 	error?: string;
+	aborted?: boolean;
 	jsonlEvents?: string[];
 	artifactPaths?: { inputPath: string; outputPath: string; jsonlPath?: string };
+	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
+	extractedToolData?: Record<string, unknown[]>;
+	/** Output metadata for Output tool integration */
+	outputMeta?: { lineCount: number; charCount: number };
 }
 
 /** Tool details for TUI rendering */

package/src/core/tools/web-fetch.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import { Type } from "@sinclair/typebox";
 import { parse as parseHtml } from "node-html-parser";
+import { logger } from "../logger";
 
 // =============================================================================
 // Types and Constants
@@ -174,9 +175,10 @@ async function loadPage(url: string, options: LoadPageOptions = {}): Promise<Loa
 			}
 
 			return { content, contentType, finalUrl, ok: true, status: response.status };
-		} catch (_err) {
+		} catch (err) {
 			// On last attempt, return failure
 			if (attempt === USER_AGENTS.length - 1) {
+				logger.debug("Web fetch failed after retries", { url, error: String(err) });
 				return { content: "", contentType: "", finalUrl: url, ok: false };
 			}
 			// Otherwise retry with next UA
@@ -2203,8 +2205,8 @@ export const webFetchTool = createWebFetchTool(process.cwd());
 
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
-import type { Theme } from "../../modes/interactive/theme/theme.js";
-import type { CustomTool, CustomToolContext, RenderResultOptions } from "../custom-tools/types.js";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import type { CustomTool, CustomToolContext, RenderResultOptions } from "../custom-tools/types";
 
 // Tree formatting constants
 const TREE_MID = "├─";

package/src/core/tools/web-search/auth.ts

@@ -10,7 +10,7 @@
 
 import * as os from "node:os";
 import * as path from "node:path";
-import type { AnthropicAuthConfig, AuthJson, ModelsJson } from "./types.js";
+import type { AnthropicAuthConfig, AuthJson, ModelsJson } from "./types";
 
 const DEFAULT_BASE_URL = "https://api.anthropic.com";