@oh-my-pi/pi-coding-agent 15.9.0 → 15.9.1

package/src/tools/ssh.ts

@@ -1,6 +1,5 @@
 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 { prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { SSHHost } from "../capability/ssh";
@@ -18,6 +17,7 @@ import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
 import { formatStyledTruncationWarning, type OutputMeta, stripOutputNotice } from "./output-meta";
+import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
@@ -230,12 +230,30 @@ interface SshRenderContext {
 	totalVisualLines?: number;
 }
 
+function formatSshCommandLines(command: string, uiTheme: Theme): string[] {
+	const sanitized = replaceTabs(command);
+	const rawLines = sanitized.length > 0 ? sanitized.split("\n") : ["…"];
+	const prefix = uiTheme.fg("dim", "$ ");
+	return rawLines.map((line, i) => (i === 0 ? `${prefix}${line}` : line));
+}
+
 export const sshToolRenderer = {
 	renderCall(args: SshRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const host = args.host || "…";
-		const command = args.command || "…";
-		const text = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}] $ ${command}` }, uiTheme);
-		return new Text(text, 0, 0);
+		const command = args.command ?? "";
+		const header = renderStatusLine({ icon: "pending", title: "SSH", description: `[${host}]` }, uiTheme);
+		const cmdLines = formatSshCommandLines(command, uiTheme);
+		const outputBlock = new CachedOutputBlock();
+		return {
+			render: (width: number): string[] =>
+				outputBlock.render(
+					{ header, state: "pending", sections: [{ lines: cmdLines }], width, animate: true },
+					uiTheme,
+				),
+			invalidate: () => {
+				outputBlock.invalidate();
+			},
+		};
 	},
 
 	renderResult(
@@ -249,11 +267,9 @@ export const sshToolRenderer = {
 	): Component {
 		const details = result.details;
 		const host = args?.host || "…";
-		const command = args?.command || "…";
-		const header = renderStatusLine(
-			{ icon: "success", title: "SSH", description: `[${host}] $ ${command}` },
-			uiTheme,
-		);
+		const command = args?.command ?? "";
+		const header = renderStatusLine({ icon: "success", title: "SSH", description: `[${host}]` }, uiTheme);
+		const cmdLines = formatSshCommandLines(command, uiTheme);
 		const textContent = result.content?.find(c => c.type === "text")?.text ?? "";
 		const outputBlock = new CachedOutputBlock();
 
@@ -303,7 +319,7 @@ export const sshToolRenderer = {
 					{
 						header,
 						state: "success",
-						sections: [{ label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
+						sections: [{ lines: cmdLines }, { label: uiTheme.fg("toolTitle", "Output"), lines: outputLines }],
 						width,
 					},
 					uiTheme,

package/src/tools/write.ts

@@ -135,6 +135,15 @@ function maybeWriteSnapshotHeader(session: ToolSession, absolutePath: string, co
 	return formatHashlineHeader(formatPathRelativeToCwd(absolutePath, session.cwd), tag);
 }
 
+function shouldRouteWriteThroughBridge(session: ToolSession, requestedPath: string, absolutePath: string): boolean {
+	if (isInternalUrlPath(requestedPath)) return false;
+
+	const state = session.getPlanModeState?.();
+	if (!state?.enabled || !isInternalUrlPath(state.planFilePath)) return true;
+
+	return absolutePath !== resolvePlanPath(session, state.planFilePath);
+}
+
 /**
  * Append a trailing note line to the first text block of a tool result.
  * Mutates `result` in place (the result object is owned by this call).
@@ -845,8 +854,11 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 				await assertEditableFile(absolutePath, path);
 			}
 
-			// Try ACP bridge first — no disk write when client handles it
-			const bridgePromise = this.#routeWriteThroughBridge(absolutePath, cleanContent);
+			// Try ACP bridge first for editor-visible filesystem paths. Internal
+			// artifacts such as local:// plans are owned by OMP, not the editor.
+			const bridgePromise = shouldRouteWriteThroughBridge(this.session, path, absolutePath)
+				? this.#routeWriteThroughBridge(absolutePath, cleanContent)
+				: undefined;
 			if (bridgePromise !== undefined) {
 				try {
 					await bridgePromise;

package/src/tui/status-line.ts

@@ -15,22 +15,33 @@ export interface StatusLineOptions {
 	meta?: string[];
 }
 
+/**
+ * Flatten CR/LF runs in caller-supplied header fragments so a single newline
+ * embedded in `description` or `meta` cannot expand the status line into
+ * multiple rows — which would otherwise break the bordered output block the
+ * header sits on. Tab characters are left alone; tool renderers that need
+ * tab-safe text run `replaceTabs()` themselves.
+ */
+function flattenForHeader(text: string): string {
+	return text.replace(/\r\n?|\n/g, " ");
+}
+
 export function renderStatusLine(options: StatusLineOptions, theme: Theme): string {
 	const icon = options.icon ? formatStatusIcon(options.icon, theme, options.spinnerFrame) : "";
 	const titleColor = options.titleColor ?? "accent";
-	const title = theme.fg(titleColor, options.title);
+	const title = theme.fg(titleColor, flattenForHeader(options.title));
 	let line = icon ? `${icon} ${title}` : title;
 
 	if (options.description) {
-		line += `: ${theme.fg("muted", options.description)}`;
+		line += `: ${theme.fg("muted", flattenForHeader(options.description))}`;
 	}
 
 	if (options.badge) {
 		const { label, color } = options.badge;
-		line += ` ${theme.fg(color, `${theme.format.bracketLeft}${label}${theme.format.bracketRight}`)}`;
+		line += ` ${theme.fg(color, `${theme.format.bracketLeft}${flattenForHeader(label)}${theme.format.bracketRight}`)}`;
 	}
 
-	const meta = options.meta?.filter(value => value.trim().length > 0) ?? [];
+	const meta = options.meta?.map(flattenForHeader).filter(value => value.trim().length > 0) ?? [];
 	if (meta.length > 0) {
 		line += ` ${theme.fg("dim", meta.join(theme.sep.dot))}`;
 	}

package/src/utils/title-generator.ts

@@ -10,7 +10,7 @@ import { resolveRoleSelection } from "../config/model-resolver";
 import type { Settings } from "../config/settings";
 import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
 import { ONLINE_TINY_TITLE_MODEL_KEY } from "../tiny/models";
-import { formatTitleUserMessage, normalizeGeneratedTitle } from "../tiny/text";
+import { formatTitleUserMessage, isLowSignalTitleInput, normalizeGeneratedTitle } from "../tiny/text";
 import { tinyTitleClient } from "../tiny/title-client";
 
 const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
@@ -31,7 +31,8 @@ const setTitleTool: Tool = {
 		properties: {
 			title: {
 				type: "string",
-				description: "A concise 3-6 word title for the session.",
+				description:
+					'A concise 3-6 word title for the session, or exactly "none" when the message carries no concrete task yet (greeting, small talk, vague).',
 			},
 		},
 		required: ["title"],
@@ -144,6 +145,12 @@ export async function generateSessionTitle(
 	currentModel?: Model<Api>,
 	metadataResolver?: (provider: string) => Record<string, unknown> | undefined,
 ): Promise<string | null> {
+	// Defer titling for greetings / acknowledgements / empty input. The default
+	// tiny title model can't reliably decline trivial input, so this happens
+	// deterministically before any model is invoked; the caller retries on the
+	// next user message while the session stays unnamed.
+	if (isLowSignalTitleInput(firstMessage)) return null;
+
 	const tinyModel = settings.get("providers.tinyModel");
 	if (tinyModel === ONLINE_TINY_TITLE_MODEL_KEY) {
 		return generateTitleOnline(firstMessage, registry, settings, sessionId, currentModel, metadataResolver);

package/src/web/search/index.ts

@@ -131,7 +131,9 @@ async function executeSearch(
 	const providers =
 		params.provider && params.provider !== "auto"
 			? await getSearchProvider(params.provider).then(async provider =>
-					(await provider.isAvailable(authStorage)) ? [provider] : resolveProviderChain(authStorage, "auto"),
+					(await provider.isExplicitlyAvailable(authStorage))
+						? [provider]
+						: resolveProviderChain(authStorage, "auto"),
 				)
 			: await resolveProviderChain(authStorage);
 	if (providers.length === 0) {

package/src/web/search/provider.ts

@@ -140,7 +140,7 @@ export async function resolveProviderChain(
 
 	if (preferredProvider !== "auto") {
 		const provider = await getSearchProvider(preferredProvider);
-		if (await provider.isAvailable(authStorage)) {
+		if (await provider.isExplicitlyAvailable(authStorage)) {
 			providers.push(provider);
 		}
 	}

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

@@ -61,9 +61,26 @@ export abstract class SearchProvider {
 	 * Indicates whether this provider has the credentials/config it needs to
 	 * service a request right now. Implementations consult the passed
 	 * {@link AuthStorage} — never a sibling store.
+	 *
+	 * Drives auto-chain admission: providers that return `false` are skipped
+	 * when {@link resolveProviderChain} walks the order. Explicit selection
+	 * uses {@link isExplicitlyAvailable} instead.
 	 */
 	abstract isAvailable(authStorage: AuthStorage): Promise<boolean> | boolean;
 
+	/**
+	 * Returns `true` when this provider should run when the user explicitly
+	 * selects it, even if {@link isAvailable} would reject it for the auto
+	 * chain. Providers that ship an unauthenticated fallback (e.g. Exa's
+	 * public MCP) override this so explicit selection still routes through
+	 * the fallback rather than silently falling back to another provider.
+	 *
+	 * Defaults to mirroring {@link isAvailable}.
+	 */
+	isExplicitlyAvailable(authStorage: AuthStorage): Promise<boolean> | boolean {
+		return this.isAvailable(authStorage);
+	}
+
 	/**
 	 * Execute a search. Credentials MUST be resolved through `params.authStorage`.
 	 */

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

@@ -8,6 +8,7 @@
  */
 import { type AuthStorage, getEnvApiKey } from "@oh-my-pi/pi-ai";
 import { settings } from "../../../config/settings";
+import { callExaTool, findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
@@ -56,6 +57,71 @@ interface ExaSearchResponse {
 	costDollars?: { total: number };
 	searchTime?: number;
 }
+function asRecord(value: unknown): Record<string, unknown> | null {
+	if (typeof value !== "object" || value === null) return null;
+	return value as Record<string, unknown>;
+}
+
+function parseOptionalField(section: string, label: string): string | null | undefined {
+	const regex = new RegExp(`(?:^|\\n)${label}:\\s*([^\\n]*)`);
+	const match = section.match(regex);
+	if (!match) return undefined;
+	const value = match[1].trim();
+	return value.length > 0 ? value : null;
+}
+
+function parseTextField(section: string): string | null | undefined {
+	const match = section.match(/(?:^|\n)Text:\s*([\s\S]*)$/);
+	if (!match) return undefined;
+	const value = match[1].trim();
+	return value.length > 0 ? value : null;
+}
+
+function parseExaMcpTextPayload(payload: unknown): ExaSearchResponse | null {
+	const root = asRecord(payload);
+	if (!root) return null;
+
+	const content = root.content;
+	if (!Array.isArray(content)) return null;
+
+	const textBlocks = content
+		.map(item => {
+			const part = asRecord(item);
+			const text = typeof part?.text === "string" ? part.text : "";
+			return text.replace(/\r\n?/g, "\n").trim();
+		})
+		.filter(text => text.length > 0);
+
+	if (textBlocks.length === 0) return null;
+
+	const sections = textBlocks
+		.join("\n\n")
+		.split(/\n{2,}(?=Title:\s*[^\n]*(?:\n(?:URL|Author|Published Date|Text):))/)
+		.map(section => section.trim())
+		.filter(section => section.startsWith("Title:"));
+
+	const results: ExaSearchResult[] = [];
+	for (const section of sections) {
+		const title = parseOptionalField(section, "Title");
+		const url = parseOptionalField(section, "URL");
+		const author = parseOptionalField(section, "Author");
+		const publishedDate = parseOptionalField(section, "Published Date");
+		const text = parseTextField(section);
+
+		if (!title && !url && !text) continue;
+
+		results.push({
+			title: title ?? undefined,
+			url: url ?? undefined,
+			author: author ?? undefined,
+			publishedDate: publishedDate ?? undefined,
+			text: text ?? undefined,
+		});
+	}
+
+	if (results.length === 0) return null;
+	return { results };
+}
 
 export function normalizeSearchType(type: ExaSearchParamType | undefined): ExaSearchType {
 	if (!type) return "auto";
@@ -133,6 +199,32 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 
 	return response.json() as Promise<ExaSearchResponse>;
 }
+function buildExaMcpArgs(params: ExaSearchParams): Record<string, unknown> {
+	const args: Record<string, unknown> = { query: params.query };
+	if (params.num_results !== undefined) args.num_results = params.num_results;
+	if (params.type !== undefined) args.type = params.type;
+	if (params.include_domains !== undefined) args.include_domains = params.include_domains;
+	if (params.exclude_domains !== undefined) args.exclude_domains = params.exclude_domains;
+	if (params.start_published_date !== undefined) args.start_published_date = params.start_published_date;
+	if (params.end_published_date !== undefined) args.end_published_date = params.end_published_date;
+	return args;
+}
+
+async function callExaMcpSearch(params: ExaSearchParams): Promise<ExaSearchResponse> {
+	const response = await callExaTool("web_search_exa", buildExaMcpArgs(params), findApiKey(), {
+		signal: withHardTimeout(params.signal),
+	});
+	if (isSearchResponse(response)) {
+		return response as ExaSearchResponse;
+	}
+
+	const parsed = parseExaMcpTextPayload(response);
+	if (parsed) {
+		return parsed;
+	}
+
+	throw new Error("Exa MCP search returned unexpected response shape.");
+}
 
 /** Execute Exa web search */
 export async function searchExa(params: ExaSearchParams): Promise<SearchResponse> {
@@ -140,11 +232,7 @@ export async function searchExa(params: ExaSearchParams): Promise<SearchResponse
 		? await params.authStorage.getApiKey("exa", params.sessionId, { signal: params.signal })
 		: undefined;
 	const apiKey = storedKey ?? getEnvApiKey("exa");
-	if (!apiKey) {
-		throw new Error("Exa credentials not found. Set EXA_API_KEY or login with 'omp /login exa'.");
-	}
-
-	const response = await callExaSearch(apiKey, params);
+	const response = apiKey ? await callExaSearch(apiKey, params) : await callExaMcpSearch(params);
 
 	// Convert to unified SearchResponse
 	const sources: SearchSource[] = [];
@@ -183,14 +271,30 @@ export class ExaProvider extends SearchProvider {
 	readonly label = "Exa";
 
 	isAvailable(authStorage: AuthStorage): boolean {
+		if (!this.#settingsAllowSearch()) return false;
+		return !!getEnvApiKey("exa") || authStorage.hasAuth("exa");
+	}
+
+	/**
+	 * Exa ships an unauthenticated public MCP fallback, so an explicit
+	 * selection (programmatic or via `providers.webSearch: exa`) routes
+	 * through MCP even when no credential is configured. The auto chain
+	 * still uses {@link isAvailable} so an unrelated configured provider
+	 * keeps priority over the public fallback.
+	 */
+	isExplicitlyAvailable(_authStorage: AuthStorage): boolean {
+		return this.#settingsAllowSearch();
+	}
+
+	#settingsAllowSearch(): boolean {
 		try {
 			if (settings.get("exa.enabled") === false || settings.get("exa.enableSearch") === false) {
 				return false;
 			}
 		} catch {
-			// Settings may be unavailable before CLI initialization; credential availability is still authoritative.
+			// Settings may be unavailable before CLI initialization; assume not disabled.
 		}
-		return authStorage.hasAuth("exa");
+		return true;
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {

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

@@ -28,7 +28,7 @@ const PERPLEXITY_OAUTH_ASK_URL = "https://www.perplexity.ai/rest/sse/perplexity_
 
 const DEFAULT_MAX_TOKENS = 8192;
 const DEFAULT_TEMPERATURE = 0.2;
-const DEFAULT_NUM_SEARCH_RESULTS = 10;
+const DEFAULT_NUM_SEARCH_RESULTS = 20;
 const OAUTH_EXPIRY_BUFFER_MS = 5 * 60 * 1000;
 const OAUTH_API_VERSION = "2.18";
 const OAUTH_USER_AGENT = "Perplexity/641 CFNetwork/1568 Darwin/25.2.0";
@@ -155,11 +155,11 @@ export interface PerplexitySearchParams {
 	system_prompt?: string;
 	search_recency_filter?: "hour" | "day" | "week" | "month" | "year";
 	num_results?: number;
-	/** Maximum output tokens. Defaults to 4096. */
+	/** Maximum output tokens. Defaults to 8192. */
 	max_tokens?: number;
 	/** Sampling temperature (0–1). Lower = more focused/factual. Defaults to 0.2. */
 	temperature?: number;
-	/** Number of search results to retrieve. Defaults to 10. */
+	/** Number of search results to retrieve. Defaults to 20. */
 	num_search_results?: number;
 	authStorage: AuthStorage;
 	sessionId?: string;
@@ -470,11 +470,14 @@ function parseResponse(response: PerplexityResponse): SearchResponse {
 		}
 	}
 
+	const relatedQuestions = (response.related_questions ?? []).filter(q => q.trim().length > 0);
+
 	return {
 		provider: "perplexity",
 		answer: answer || undefined,
 		sources,
 		citations: citations.length > 0 ? citations : undefined,
+		relatedQuestions: relatedQuestions.length > 0 ? relatedQuestions : undefined,
 		usage: response.usage
 			? {
 					inputTokens: response.usage.prompt_tokens,
@@ -532,11 +535,12 @@ export async function searchPerplexity(params: PerplexitySearchParams): Promise<
 		num_search_results: params.num_search_results ?? DEFAULT_NUM_SEARCH_RESULTS,
 		web_search_options: {
 			search_type: "pro",
-			search_context_size: "medium",
+			search_context_size: "high",
 		},
 		enable_search_classifier: true,
 		reasoning_effort: "medium",
 		language_preference: "en",
+		return_related_questions: true,
 	};
 
 	if (params.search_recency_filter) {

package/src/web/search/types.ts

@@ -53,7 +53,7 @@ export const SEARCH_PROVIDER_OPTIONS = [
 		description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)",
 	},
 	{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
-	{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
+	{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set; falls back to Exa MCP" },
 	{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
 	{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
 	{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
@@ -472,6 +472,7 @@ export interface PerplexityResponse {
 	choices: PerplexityChoice[];
 	citations?: string[] | null;
 	search_results?: PerplexitySearchResult[] | null;
+	related_questions?: string[] | null;
 	type?: PerplexityCompletionResponseType | null;
 	status?: PerplexityCompletionResponseStatus | null;
 }