@oh-my-pi/pi-coding-agent 13.3.13 → 13.4.0

package/src/tools/index.ts

@@ -15,8 +15,8 @@ import type { AgentOutputManager } from "../task/output-manager";
 import type { EventBus } from "../utils/event-bus";
 import { SearchTool } from "../web/search";
 import { AskTool } from "./ask";
-import { AstFindTool } from "./ast-find";
-import { AstReplaceTool } from "./ast-replace";
+import { AstEditTool } from "./ast-edit";
+import { AstGrepTool } from "./ast-grep";
 import { AwaitTool } from "./await-tool";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
@@ -30,6 +30,7 @@ import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
+import { ResolveTool } from "./resolve";
 import { reportFindingTool } from "./review";
 import { loadSshTool } from "./ssh";
 import { SubmitResultTool } from "./submit-result";
@@ -38,50 +39,36 @@ import { WriteTool } from "./write";
 
 // Exa MCP tools (22 tools)
 
-export { exaTools } from "../exa";
-export type { ExaRenderDetails, ExaSearchResponse, ExaSearchResult } from "../exa/types";
-export {
-	type FileDiagnosticsResult,
-	type FileFormatResult,
-	getLspStatus,
-	type LspServerStatus,
-	LspTool,
-	type LspToolDetails,
-	type LspWarmupOptions,
-	type LspWarmupResult,
-	warmupLspServers,
-} from "../lsp";
-export { EditTool, type EditToolDetails } from "../patch";
+export * from "../exa";
+export type * from "../exa/types";
+export * from "../lsp";
+export * from "../patch";
 export * from "../session/streaming-output";
-export { BUNDLED_AGENTS, TaskTool } from "../task";
+export * from "../task";
 export * from "../web/search";
-export { AskTool, type AskToolDetails } from "./ask";
-export { AstFindTool, type AstFindToolDetails } from "./ast-find";
-export { AstReplaceTool, type AstReplaceToolDetails } from "./ast-replace";
-export { AwaitTool, type AwaitToolDetails } from "./await-tool";
-export { BashTool, type BashToolDetails, type BashToolInput, type BashToolOptions } from "./bash";
-export { BrowserTool, type BrowserToolDetails } from "./browser";
-export { CalculatorTool, type CalculatorToolDetails } from "./calculator";
-export { CancelJobTool, type CancelJobToolDetails } from "./cancel-job";
-export { type ExitPlanModeDetails, ExitPlanModeTool } from "./exit-plan-mode";
-export { FetchTool, type FetchToolDetails } from "./fetch";
-export { type FindOperations, FindTool, type FindToolDetails, type FindToolInput, type FindToolOptions } from "./find";
-export { setPreferredImageProvider } from "./gemini-image";
-export { GrepTool, type GrepToolDetails, type GrepToolInput } from "./grep";
-export { NotebookTool, type NotebookToolDetails } from "./notebook";
-export { PythonTool, type PythonToolDetails, type PythonToolOptions } from "./python";
-export { ReadTool, type ReadToolDetails, type ReadToolInput } from "./read";
-export { reportFindingTool, type SubmitReviewDetails } from "./review";
-export { loadSshTool, type SSHToolDetails, SshTool } from "./ssh";
-export { SubmitResultTool } from "./submit-result";
-export {
-	getLatestTodoPhasesFromEntries,
-	type TodoItem,
-	type TodoPhase,
-	TodoWriteTool,
-	type TodoWriteToolDetails,
-} from "./todo-write";
-export { WriteTool, type WriteToolDetails, type WriteToolInput } from "./write";
+export * from "./ask";
+export * from "./ast-edit";
+export * from "./ast-grep";
+export * from "./await-tool";
+export * from "./bash";
+export * from "./browser";
+export * from "./calculator";
+export * from "./cancel-job";
+export * from "./exit-plan-mode";
+export * from "./fetch";
+export * from "./find";
+export * from "./gemini-image";
+export * from "./grep";
+export * from "./notebook";
+export * from "./pending-action";
+export * from "./python";
+export * from "./read";
+export * from "./resolve";
+export * from "./review";
+export * from "./ssh";
+export * from "./submit-result";
+export * from "./todo-write";
+export * from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
 export type Tool = AgentTool<any, any, any>;
@@ -154,13 +141,15 @@ export interface ToolSession {
 	getTodoPhases?: () => TodoPhase[];
 	/** Replace cached todo phases for this session. */
 	setTodoPhases?: (phases: TodoPhase[]) => void;
+	/** Pending action store for preview/apply workflows */
+	pendingActionStore?: import("./pending-action").PendingActionStore;
 }
 
 type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
-	ast_find: s => new AstFindTool(s),
-	ast_replace: s => new AstReplaceTool(s),
+	ast_grep: s => new AstGrepTool(s),
+	ast_edit: s => new AstEditTool(s),
 	ask: AskTool.createIf,
 	bash: s => new BashTool(s),
 	python: s => new PythonTool(s),
@@ -186,6 +175,7 @@ export const HIDDEN_TOOLS: Record<string, ToolFactory> = {
 	submit_result: s => new SubmitResultTool(s),
 	report_finding: () => reportFindingTool,
 	exit_plan_mode: s => new ExitPlanModeTool(s),
+	resolve: s => new ResolveTool(s),
 };
 
 export type ToolName = keyof typeof BUILTIN_TOOLS;
@@ -289,8 +279,8 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		if (name === "todo_write") return !includeSubmitResult && session.settings.get("todo.enabled");
 		if (name === "find") return session.settings.get("find.enabled");
 		if (name === "grep") return session.settings.get("grep.enabled");
-		if (name === "ast_find") return session.settings.get("astFind.enabled");
-		if (name === "ast_replace") return session.settings.get("astReplace.enabled");
+		if (name === "ast_grep") return session.settings.get("astGrep.enabled");
+		if (name === "ast_edit") return session.settings.get("astEdit.enabled");
 		if (name === "notebook") return session.settings.get("notebook.enabled");
 		if (name === "fetch") return session.settings.get("fetch.enabled");
 		if (name === "web_search") return session.settings.get("web_search.enabled");
@@ -309,24 +299,32 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 	}
 
 	const filteredRequestedTools = requestedTools?.filter(name => name in allTools && isToolAllowed(name));
-
-	const entries =
+	const baseEntries =
 		filteredRequestedTools !== undefined
-			? filteredRequestedTools.map(name => [name, allTools[name]] as const)
+			? filteredRequestedTools.filter(name => name !== "resolve").map(name => [name, allTools[name]] as const)
 			: [
 					...Object.entries(BUILTIN_TOOLS).filter(([name]) => isToolAllowed(name)),
 					...(includeSubmitResult ? ([["submit_result", HIDDEN_TOOLS.submit_result]] as const) : []),
 					...([["exit_plan_mode", HIDDEN_TOOLS.exit_plan_mode]] as const),
 				];
 
-	const results = await Promise.all(
-		entries.map(async ([name, factory]) => {
-			if (filteredRequestedTools && !filteredRequestedTools.includes(name)) {
-				return null;
-			}
+	const baseResults = await Promise.all(
+		baseEntries.map(async ([name, factory]) => {
 			const tool = await logger.timeAsync(`createTools:${name}`, factory, session);
 			return tool ? wrapToolWithMetaNotice(tool) : null;
 		}),
 	);
-	return results.filter((r): r is Tool => r !== null);
+	const tools = baseResults.filter((r): r is Tool => r !== null);
+	const hasDeferrableTools = tools.some(tool => tool.deferrable === true);
+	if (!hasDeferrableTools) {
+		return tools;
+	}
+	if (tools.some(tool => tool.name === "resolve")) {
+		return tools;
+	}
+	const resolveTool = await logger.timeAsync("createTools:resolve", HIDDEN_TOOLS.resolve, session);
+	if (resolveTool) {
+		tools.push(wrapToolWithMetaNotice(resolveTool));
+	}
+	return tools;
 }

package/src/tools/pending-action.ts

@@ -0,0 +1,33 @@
+import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
+
+export interface PendingAction {
+	label: string;
+	sourceToolName: string;
+	apply(reason: string): Promise<AgentToolResult<unknown>>;
+	reject?(reason: string): Promise<AgentToolResult<unknown> | undefined>;
+	details?: unknown;
+}
+
+export class PendingActionStore {
+	#actions: PendingAction[] = [];
+
+	push(action: PendingAction): void {
+		this.#actions.push(action);
+	}
+
+	peek(): PendingAction | null {
+		return this.#actions.at(-1) ?? null;
+	}
+
+	pop(): PendingAction | null {
+		return this.#actions.pop() ?? null;
+	}
+
+	clear(): void {
+		this.#actions = [];
+	}
+
+	get hasPending(): boolean {
+		return this.#actions.length > 0;
+	}
+}

package/src/tools/render-utils.ts

@@ -530,3 +530,13 @@ export function shortenPath(filePath: string, homeDir?: string): string {
 export function wrapBrackets(text: string, theme: Theme): string {
 	return `${theme.format.bracketLeft}${text}${theme.format.bracketRight}`;
 }
+
+export const PARSE_ERRORS_LIMIT = 20;
+
+export function formatParseErrors(errors: string[]): string[] {
+	if (errors.length === 0) return [];
+	const capped = errors.slice(0, PARSE_ERRORS_LIMIT);
+	const header =
+		errors.length > PARSE_ERRORS_LIMIT ? `Parse issues (${PARSE_ERRORS_LIMIT} / ${errors.length}):` : "Parse issues:";
+	return [header, ...capped.map(err => `- ${err}`)];
+}

package/src/tools/renderers.ts

@@ -11,8 +11,8 @@ import { editToolRenderer } from "../patch";
 import { taskToolRenderer } from "../task/render";
 import { webSearchToolRenderer } from "../web/search/render";
 import { askToolRenderer } from "./ask";
-import { astFindToolRenderer } from "./ast-find";
-import { astReplaceToolRenderer } from "./ast-replace";
+import { astEditToolRenderer } from "./ast-edit";
+import { astGrepToolRenderer } from "./ast-grep";
 import { bashToolRenderer } from "./bash";
 import { calculatorToolRenderer } from "./calculator";
 import { fetchToolRenderer } from "./fetch";
@@ -21,6 +21,7 @@ import { grepToolRenderer } from "./grep";
 import { notebookToolRenderer } from "./notebook";
 import { pythonToolRenderer } from "./python";
 import { readToolRenderer } from "./read";
+import { resolveToolRenderer } from "./resolve";
 import { sshToolRenderer } from "./ssh";
 import { todoWriteToolRenderer } from "./todo-write";
 import { writeToolRenderer } from "./write";
@@ -40,8 +41,8 @@ type ToolRenderer = {
 
 export const toolRenderers: Record<string, ToolRenderer> = {
 	ask: askToolRenderer as ToolRenderer,
-	ast_find: astFindToolRenderer as ToolRenderer,
-	ast_replace: astReplaceToolRenderer as ToolRenderer,
+	ast_grep: astGrepToolRenderer as ToolRenderer,
+	ast_edit: astEditToolRenderer as ToolRenderer,
 	bash: bashToolRenderer as ToolRenderer,
 	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,
@@ -51,6 +52,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	lsp: lspToolRenderer as ToolRenderer,
 	notebook: notebookToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
+	resolve: resolveToolRenderer as ToolRenderer,
 	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,
 	todo_write: todoWriteToolRenderer as ToolRenderer,

package/src/tools/resolve.ts

@@ -0,0 +1,156 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { untilAborted } from "@oh-my-pi/pi-utils";
+import { type Static, Type } from "@sinclair/typebox";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import type { Theme } from "../modes/theme/theme";
+import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
+import { Ellipsis, padToWidth, renderStatusLine, truncateToWidth } from "../tui";
+import type { ToolSession } from ".";
+import { replaceTabs } from "./render-utils";
+import { ToolError } from "./tool-errors";
+import { toolResult } from "./tool-result";
+
+const resolveSchema = Type.Object({
+	action: Type.Union([Type.Literal("apply"), Type.Literal("discard")]),
+	reason: Type.String({ description: "Why you're applying or discarding" }),
+});
+
+type ResolveParams = Static<typeof resolveSchema>;
+
+export interface ResolveToolDetails {
+	action: "apply" | "discard";
+	reason: string;
+	sourceToolName?: string;
+	label?: string;
+}
+
+function resolveReasonPreview(reason?: string): string | undefined {
+	const trimmed = reason?.trim();
+	if (!trimmed) return undefined;
+	return truncateToWidth(trimmed, 72, Ellipsis.Omit);
+}
+
+export class ResolveTool implements AgentTool<typeof resolveSchema, ResolveToolDetails> {
+	readonly name = "resolve";
+	readonly label = "Resolve";
+	readonly hidden = true;
+	readonly description: string;
+	readonly parameters = resolveSchema;
+	readonly strict = true;
+
+	constructor(private readonly session: ToolSession) {
+		this.description = renderPromptTemplate(resolveDescription);
+	}
+
+	async execute(
+		_toolCallId: string,
+		params: ResolveParams,
+		signal?: AbortSignal,
+		_onUpdate?: AgentToolUpdateCallback<ResolveToolDetails>,
+		_context?: AgentToolContext,
+	): Promise<AgentToolResult<ResolveToolDetails>> {
+		return untilAborted(signal, async () => {
+			const store = this.session.pendingActionStore;
+			if (!store || !store.hasPending) {
+				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
+			}
+
+			const pendingAction = store.pop();
+			if (!pendingAction) {
+				throw new ToolError("No pending action to resolve. Nothing to apply or discard.");
+			}
+			const resolveDetails: ResolveToolDetails = {
+				action: params.action,
+				reason: params.reason,
+				sourceToolName: pendingAction.sourceToolName,
+				label: pendingAction.label,
+			};
+
+			if (params.action === "apply") {
+				const applyResult = await pendingAction.apply(params.reason);
+				const appliedText = applyResult.content
+					.filter(part => part.type === "text")
+					.map(part => part.text)
+					.filter(text => text != null && text.length > 0)
+					.join("\n");
+				const baseResult = toolResult()
+					.text(appliedText || `Applied: ${pendingAction.label}.`)
+					.done();
+				return { ...baseResult, details: resolveDetails };
+			}
+
+			if (params.action === "discard" && pendingAction.reject != null) {
+				const discardResult = await pendingAction.reject(params.reason);
+				if (discardResult != null) {
+					return { ...discardResult, details: resolveDetails };
+				}
+			}
+			const discardResult = toolResult().text(`Discarded: ${pendingAction.label}. Reason: ${params.reason}`).done();
+			return { ...discardResult, details: resolveDetails };
+		});
+	}
+}
+
+export const resolveToolRenderer = {
+	renderCall(args: ResolveParams, _options: RenderResultOptions, uiTheme: Theme): Component {
+		const reason = resolveReasonPreview(args.reason);
+		const text = renderStatusLine(
+			{
+				icon: "pending",
+				title: "Resolve",
+				description: args.action,
+				badge: {
+					label: args.action === "apply" ? "proposed -> resolved" : "proposed -> rejected",
+					color: args.action === "apply" ? "success" : "warning",
+				},
+				meta: reason ? [uiTheme.fg("muted", reason)] : undefined,
+			},
+			uiTheme,
+		);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: ResolveToolDetails; isError?: boolean },
+		_options: RenderResultOptions,
+		uiTheme: Theme,
+	): Component {
+		const details = result.details;
+		const label = replaceTabs(details?.label ?? "pending action");
+		const reason = replaceTabs(details?.reason?.trim() || "No reason provided");
+		const action = details?.action ?? "apply";
+		const isApply = action === "apply" && !result.isError;
+		const bgColor = result.isError ? "error" : isApply ? "success" : "warning";
+		const icon = isApply ? uiTheme.status.success : uiTheme.status.error;
+		const verb = isApply ? "Accept" : "Discard";
+		const separator = ": ";
+		const separatorIndex = label.indexOf(separator);
+		const sourceLabel = separatorIndex > 0 ? label.slice(0, separatorIndex).trim() : undefined;
+		const summaryLabel = separatorIndex > 0 ? label.slice(separatorIndex + separator.length).trim() : label;
+		const sourceBadge = sourceLabel
+			? uiTheme.bold(`${uiTheme.format.bracketLeft}${sourceLabel}${uiTheme.format.bracketRight}`)
+			: undefined;
+		const headerLine = `${icon} ${uiTheme.bold(`${verb}:`)} ${summaryLabel}${sourceBadge ? ` ${sourceBadge}` : ""}`;
+		const lines = ["", headerLine, "", uiTheme.italic(reason), ""];
+
+		return {
+			render(width: number) {
+				const lineWidth = Math.max(3, width);
+				const innerWidth = Math.max(1, lineWidth - 2);
+				return lines.map(line => {
+					const truncated = truncateToWidth(line, innerWidth, Ellipsis.Omit);
+					const framed = ` ${padToWidth(truncated, innerWidth)} `;
+					const padded = padToWidth(framed, lineWidth);
+					return uiTheme.inverse(uiTheme.fg(bgColor, padded));
+				});
+			},
+			invalidate() {},
+		};
+	},
+
+	inline: true,
+	mergeCallAndResult: true,
+};

package/src/tools/submit-result.ts

@@ -4,7 +4,7 @@
  * Subagents must call this tool to finish and return structured JSON output.
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/typebox-helpers";
+import { sanitizeSchemaForStrictMode } from "@oh-my-pi/pi-ai/utils/schema";
 import type { Static, TSchema } from "@sinclair/typebox";
 import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";

package/src/web/search/index.ts

@@ -46,6 +46,9 @@ export const webSearchSchema = Type.Object({
 		}),
 	),
 	limit: Type.Optional(Type.Number({ description: "Max results to return" })),
+	max_tokens: Type.Optional(Type.Number({ description: "Maximum output tokens" })),
+	temperature: Type.Optional(Type.Number({ description: "Sampling temperature" })),
+	num_search_results: Type.Optional(Type.Number({ description: "Number of search results to retrieve" })),
 });
 
 export type SearchParams = {
@@ -70,7 +73,7 @@ export type SearchParams = {
 	temperature?: number;
 	/** Number of search results to retrieve. Defaults to 10. */
 	num_search_results?: number;
-	/** Disable provider fallback when explicit provider is selected (CLI/debug use). */
+	/** Deprecated CLI flag; explicit provider fallback now happens only when provider is unavailable. */
 	no_fallback?: boolean;
 };
 
@@ -185,12 +188,11 @@ async function executeSearch(
 	params: SearchParams,
 ): Promise<{ content: Array<{ type: "text"; text: string }>; details: SearchRenderDetails }> {
 	const providers =
-		params.provider && params.provider !== "auto" && params.no_fallback
+		params.provider && params.provider !== "auto"
 			? (await getSearchProvider(params.provider).isAvailable())
 				? [getSearchProvider(params.provider)]
-				: []
+				: await resolveProviderChain("auto")
 			: await resolveProviderChain(params.provider);
-
 	if (providers.length === 0) {
 		const message = "No web search provider configured.";
 		return {

package/src/web/search/providers/anthropic.ts

@@ -7,7 +7,7 @@
 import {
 	type AnthropicAuthConfig,
 	type AnthropicSystemBlock,
-	buildAnthropicHeaders,
+	buildAnthropicSearchHeaders,
 	buildAnthropicSystemBlocks,
 	buildAnthropicUrl,
 	findAnthropicAuth,
@@ -87,7 +87,7 @@ async function callSearch(
 	temperature?: number,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
-	const headers = buildAnthropicHeaders(auth);
+	const headers = buildAnthropicSearchHeaders(auth);
 
 	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 

package/src/web/search/providers/base.ts

@@ -10,6 +10,9 @@ export interface SearchParams {
 	maxOutputTokens?: number;
 	numSearchResults?: number;
 	temperature?: number;
+	googleSearch?: Record<string, unknown>;
+	codeExecution?: Record<string, unknown>;
+	urlContext?: Record<string, unknown>;
 }
 
 /** Base class for web search providers. */

package/src/web/search/providers/exa.ts

@@ -7,6 +7,7 @@
  * them into a combined `answer` string on the SearchResponse.
  */
 import { getEnvApiKey } from "@oh-my-pi/pi-ai";
+import { callExaTool, findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import { dateToAgeSeconds } from "../utils";
@@ -121,14 +122,19 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 	return response.json() as Promise<ExaSearchResponse>;
 }
 
+async function callExaMcpSearch(params: ExaSearchParams): Promise<ExaSearchResponse> {
+	const response = await callExaTool("web_search_exa", { ...params }, findApiKey());
+	if (!isSearchResponse(response)) {
+		throw new Error("Exa MCP search returned unexpected response shape.");
+	}
+
+	return response as ExaSearchResponse;
+}
+
 /** Execute Exa web search */
 export async function searchExa(params: ExaSearchParams): Promise<SearchResponse> {
 	const apiKey = getEnvApiKey("exa");
-	if (!apiKey) {
-		throw new Error("EXA_API_KEY not found. Set it in environment or .env file.");
-	}
-
-	const response = await callExaSearch(apiKey, params);
+	const response = apiKey ? await callExaSearch(apiKey, params) : await callExaMcpSearch(params);
 
 	// Convert to unified SearchResponse
 	const sources: SearchSource[] = [];