@oh-my-pi/pi-coding-agent 3.33.0 → 3.35.0

package/src/core/tools/ssh.ts

@@ -0,0 +1,302 @@
+import type { AgentTool, AgentToolContext } 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 { Type } from "@sinclair/typebox";
+import type { SSHHost } from "../../capability/ssh";
+import { sshCapability } from "../../capability/ssh";
+import { loadSync } from "../../discovery/index";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import sshDescriptionBase from "../../prompts/tools/ssh.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { SSHHostInfo } from "../ssh/connection-manager";
+import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
+import { executeSSH } from "../ssh/ssh-executor";
+import type { ToolSession } from "./index";
+import { createToolUIKit } from "./render-utils";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+
+const sshSchema = Type.Object({
+	host: Type.String({ description: "Host name from ssh.json or .ssh.json" }),
+	command: Type.String({ description: "Command to execute on the remote host" }),
+	cwd: Type.Optional(Type.String({ description: "Remote working directory (optional)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+
+export interface SSHToolDetails {
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+function formatHostEntry(host: SSHHost): string {
+	const info = getHostInfoForHost(host);
+
+	let shell: string;
+	if (!info) {
+		shell = "detecting...";
+	} else if (info.os === "windows") {
+		if (info.compatEnabled) {
+			const compatShell = info.compatShell || "bash";
+			shell = `windows/${compatShell}`;
+		} else if (info.shell === "powershell") {
+			shell = "windows/powershell";
+		} else {
+			shell = "windows/cmd";
+		}
+	} else if (info.os === "linux") {
+		shell = `linux/${info.shell}`;
+	} else if (info.os === "macos") {
+		shell = `macos/${info.shell}`;
+	} else {
+		shell = `unknown/${info.shell}`;
+	}
+
+	return `- ${host.name} (${host.host}) | ${shell}`;
+}
+
+function formatDescription(hosts: SSHHost[]): string {
+	if (hosts.length === 0) {
+		return sshDescriptionBase;
+	}
+	const hostList = hosts.map(formatHostEntry).join("\n");
+	return `${sshDescriptionBase}\n\nAvailable hosts:\n${hostList}`;
+}
+
+function quoteRemotePath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "'\\''");
+	return `'${escaped}'`;
+}
+
+function quotePowerShellPath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "''");
+	return `'${escaped}'`;
+}
+
+function quoteCmdPath(value: string): string {
+	const escaped = value.replace(/"/g, '""');
+	return `"${escaped}"`;
+}
+
+function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHHostInfo): string {
+	if (!cwd) return command;
+
+	if (info.os === "windows" && !info.compatEnabled) {
+		if (info.shell === "powershell") {
+			return `Set-Location -Path ${quotePowerShellPath(cwd)}; ${command}`;
+		}
+		return `cd /d ${quoteCmdPath(cwd)} && ${command}`;
+	}
+
+	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
+}
+
+function loadHosts(session: ToolSession): {
+	hostNames: string[];
+	hostsByName: Map<string, SSHHost>;
+} {
+	const result = loadSync<SSHHost>(sshCapability.id, { cwd: session.cwd });
+	const hostsByName = new Map<string, SSHHost>();
+	for (const host of result.items) {
+		if (!hostsByName.has(host.name)) {
+			hostsByName.set(host.name, host);
+		}
+	}
+	const hostNames = Array.from(hostsByName.keys()).sort();
+	return { hostNames, hostsByName };
+}
+
+export function createSshTool(session: ToolSession): AgentTool<typeof sshSchema> | null {
+	const { hostNames, hostsByName } = loadHosts(session);
+	if (hostNames.length === 0) {
+		return null;
+	}
+
+	const allowedHosts = new Set(hostNames);
+
+	const descriptionHosts = hostNames
+		.map((name) => hostsByName.get(name))
+		.filter((host): host is SSHHost => host !== undefined);
+
+	return {
+		name: "ssh",
+		label: "SSH",
+		description: formatDescription(descriptionHosts),
+		parameters: sshSchema,
+		execute: async (
+			_toolCallId: string,
+			{ host, command, cwd, timeout }: { host: string; command: string; cwd?: string; timeout?: number },
+			signal?: AbortSignal,
+			onUpdate?,
+			_ctx?: AgentToolContext,
+		) => {
+			if (!allowedHosts.has(host)) {
+				throw new Error(`Unknown SSH host: ${host}. Available hosts: ${hostNames.join(", ")}`);
+			}
+
+			const hostConfig = hostsByName.get(host);
+			if (!hostConfig) {
+				throw new Error(`SSH host not loaded: ${host}`);
+			}
+
+			const hostInfo = await ensureHostInfo(hostConfig);
+			const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
+			let currentOutput = "";
+
+			const result = await executeSSH(hostConfig, remoteCommand, {
+				timeout: timeout ? timeout * 1000 : undefined,
+				signal,
+				compatEnabled: hostInfo.compatEnabled,
+				onChunk: (chunk) => {
+					currentOutput += chunk;
+					if (onUpdate) {
+						const truncation = truncateTail(currentOutput);
+						onUpdate({
+							content: [{ type: "text", text: truncation.content || "" }],
+							details: {
+								truncation: truncation.truncated ? truncation : undefined,
+							},
+						});
+					}
+				},
+			});
+
+			if (result.cancelled) {
+				throw new Error(result.output || "Command aborted");
+			}
+
+			const truncation = truncateTail(result.output);
+			let outputText = truncation.content || "(no output)";
+
+			let details: SSHToolDetails | undefined;
+
+			if (truncation.truncated) {
+				details = {
+					truncation,
+					fullOutputPath: result.fullOutputPath,
+				};
+
+				const startLine = truncation.totalLines - truncation.outputLines + 1;
+				const endLine = truncation.totalLines;
+
+				if (truncation.lastLinePartial) {
+					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
+					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
+				} else if (truncation.truncatedBy === "lines") {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
+				} else {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
+				}
+			}
+
+			if (result.exitCode !== 0 && result.exitCode !== undefined) {
+				outputText += `\n\nCommand exited with code ${result.exitCode}`;
+				throw new Error(outputText);
+			}
+
+			return { content: [{ type: "text", text: outputText }], details };
+		},
+	};
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface SshRenderArgs {
+	host?: string;
+	command?: string;
+	timeout?: number;
+}
+
+interface SshRenderContext {
+	/** Visual lines for truncated output (pre-computed by tool-execution) */
+	visualLines?: string[];
+	/** Number of lines skipped */
+	skippedCount?: number;
+	/** Total visual lines */
+	totalVisualLines?: number;
+}
+
+export const sshToolRenderer = {
+	renderCall(args: SshRenderArgs, uiTheme: Theme): Component {
+		const ui = createToolUIKit(uiTheme);
+		const host = args.host || uiTheme.format.ellipsis;
+		const command = args.command || uiTheme.format.ellipsis;
+		const text = ui.title(`[${host}] $ ${command}`);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: {
+			content: Array<{ type: string; text?: string }>;
+			details?: SSHToolDetails;
+		},
+		options: RenderResultOptions & { renderContext?: SshRenderContext },
+		uiTheme: Theme,
+	): Component {
+		const ui = createToolUIKit(uiTheme);
+		const { expanded, renderContext } = options;
+		const details = result.details;
+		const lines: string[] = [];
+
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+		const output = textContent.trim();
+
+		if (output) {
+			if (expanded) {
+				const styledOutput = output
+					.split("\n")
+					.map((line) => uiTheme.fg("toolOutput", line))
+					.join("\n");
+				lines.push(styledOutput);
+			} else if (renderContext?.visualLines) {
+				const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
+				if (skippedCount > 0) {
+					lines.push(
+						uiTheme.fg(
+							"dim",
+							`${uiTheme.format.ellipsis} (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
+						),
+					);
+				}
+				lines.push(...visualLines);
+			} else {
+				const outputLines = output.split("\n");
+				const maxLines = 5;
+				const displayLines = outputLines.slice(0, maxLines);
+				const remaining = outputLines.length - maxLines;
+
+				lines.push(...displayLines.map((line) => uiTheme.fg("toolOutput", line)));
+				if (remaining > 0) {
+					lines.push(uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${remaining} more lines) (ctrl+o to expand)`));
+				}
+			}
+		}
+
+		const truncation = details?.truncation;
+		const fullOutputPath = details?.fullOutputPath;
+		if (truncation?.truncated || fullOutputPath) {
+			const warnings: string[] = [];
+			if (fullOutputPath) {
+				warnings.push(`Full output: ${fullOutputPath}`);
+			}
+			if (truncation?.truncated) {
+				if (truncation.truncatedBy === "lines") {
+					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+				} else {
+					warnings.push(
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+					);
+				}
+			}
+			lines.push(uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". "))));
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};

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

@@ -13,8 +13,8 @@
  *   - Session artifacts for debugging
  */
 
-import type { Usage } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../../modes/interactive/theme/theme";
 import taskDescriptionTemplate from "../../../prompts/tools/task.md" with { type: "text" };
 import { formatDuration } from "../render-utils";
@@ -135,7 +135,12 @@ export async function createTaskTool(
 			const startTime = Date.now();
 			const { agents, projectAgentsDir } = await discoverAgents(session.cwd);
 			const { agent: agentName, context, model, output: outputSchema } = params;
-			const modelOverride = model ?? session.getModelString?.();
+
+			const isDefaultModelAlias = (value: string | undefined): boolean => {
+				if (!value) return true;
+				const normalized = value.trim().toLowerCase();
+				return normalized === "default" || normalized === "pi/default" || normalized === "omp/default";
+			};
 
 			// Validate agent exists
 			const agent = getAgent(agents, agentName);
@@ -156,6 +161,10 @@ export async function createTaskTool(
 				};
 			}
 
+			const shouldInheritSessionModel = model === undefined && isDefaultModelAlias(agent.model);
+			const sessionModel = shouldInheritSessionModel ? session.getActiveModelString?.() : undefined;
+			const modelOverride = model ?? sessionModel ?? session.getModelString?.();
+
 			// Handle empty or missing tasks
 			if (!params.tasks || params.tasks.length === 0) {
 				return {

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

@@ -8,7 +8,7 @@
  *   - Fuzzy match: "opus" → "p-anthropic/claude-opus-4-5"
  *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
  *   - "default" → undefined (use system default)
- *   - "omp/slow" → configured slow model from settings
+ *   - "omp/slow" or "pi/slow" → configured slow model from settings
  */
 
 import { type Settings, settingsCapability } from "../../../capability/settings";
@@ -145,9 +145,10 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 		.filter(Boolean);
 
 	for (const p of patterns) {
-		// Handle omp/<role> aliases - looks up role in settings.modelRoles
-		if (p.toLowerCase().startsWith("omp/")) {
-			const role = p.slice(4); // Remove "omp/" prefix
+		// Handle omp/<role> or pi/<role> aliases - looks up role in settings.modelRoles
+		const lower = p.toLowerCase();
+		if (lower.startsWith("omp/") || lower.startsWith("pi/")) {
+			const role = lower.startsWith("omp/") ? p.slice(4) : p.slice(3);
 			const resolved = resolveOmpAlias(role, models);
 			if (resolved) return resolved;
 			continue; // Role not configured, try next pattern

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

@@ -1,4 +1,4 @@
-import type { Usage } from "@mariozechner/pi-ai";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import { type Static, Type } from "@sinclair/typebox";
 
 /** Source of an agent definition */

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

@@ -13,8 +13,8 @@
  * 5. Parent can send { type: "abort" } to request cancellation
  */
 
-import type { Api, Model } from "@mariozechner/pi-ai";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
 import type { AgentSessionEvent } from "../../agent-session";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";

package/src/core/voice.ts

@@ -1,7 +1,7 @@
 import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { completeSimple, type Model } from "@mariozechner/pi-ai";
+import { completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { nanoid } from "nanoid";
 import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
 import { logger } from "./logger";

package/src/discovery/index.ts

@@ -18,6 +18,7 @@ import "../capability/settings";
 import "../capability/skill";
 import "../capability/slash-command";
 import "../capability/system-prompt";
+import "../capability/ssh";
 import "../capability/tool";
 
 // Import providers (each registers itself on import)
@@ -32,6 +33,7 @@ import "./github";
 import "./vscode";
 import "./agents-md";
 import "./mcp-json";
+import "./ssh";
 
 export type { ContextFile } from "../capability/context-file";
 export type { Extension, ExtensionManifest } from "../capability/extension";
@@ -70,6 +72,7 @@ export type { Rule, RuleFrontmatter } from "../capability/rule";
 export type { Settings } from "../capability/settings";
 export type { Skill, SkillFrontmatter } from "../capability/skill";
 export type { SlashCommand } from "../capability/slash-command";
+export type { SSHHost } from "../capability/ssh";
 export type { SystemPrompt } from "../capability/system-prompt";
 export type { CustomTool } from "../capability/tool";
 // Re-export types

package/src/discovery/ssh.ts

@@ -0,0 +1,162 @@
+/**
+ * SSH JSON Provider
+ *
+ * Discovers SSH hosts from ssh.json or .ssh.json in the project root.
+ * Priority: 5 (low, project-level only)
+ */
+
+import { join } from "node:path";
+import { registerProvider } from "../capability/index";
+import { type SSHHost, sshCapability } from "../capability/ssh";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { createSourceMeta, expandEnvVarsDeep, parseJSON } from "./helpers";
+
+const PROVIDER_ID = "ssh-json";
+const DISPLAY_NAME = "SSH Config";
+
+interface SSHConfigFile {
+	hosts?: Record<
+		string,
+		{
+			host?: string;
+			username?: string;
+			port?: number | string;
+			compat?: boolean | string;
+			key?: string;
+			keyPath?: string;
+			description?: string;
+		}
+	>;
+}
+
+function expandTilde(value: string, home: string): string {
+	if (value === "~") return home;
+	if (value.startsWith("~/") || value.startsWith("~\\")) {
+		return `${home}${value.slice(1)}`;
+	}
+	return value;
+}
+
+function parsePort(value: number | string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+function parseCompat(value: boolean | string | undefined): boolean | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "boolean") return value;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1" || normalized === "yes") return true;
+	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
+	return undefined;
+}
+
+function normalizeHost(
+	name: string,
+	raw: NonNullable<SSHConfigFile["hosts"]>[string],
+	source: SourceMeta,
+	home: string,
+	warnings: string[],
+): SSHHost | null {
+	if (!raw.host) {
+		warnings.push(`Missing host for SSH entry: ${name}`);
+		return null;
+	}
+
+	const port = parsePort(raw.port);
+	if (raw.port !== undefined && port === undefined) {
+		warnings.push(`Invalid port for SSH entry ${name}: ${String(raw.port)}`);
+	}
+
+	const compat = parseCompat(raw.compat);
+	if (raw.compat !== undefined && compat === undefined) {
+		warnings.push(`Invalid compat flag for SSH entry ${name}: ${String(raw.compat)}`);
+	}
+
+	const keyValue = raw.keyPath ?? raw.key;
+	const keyPath = keyValue ? expandTilde(keyValue, home) : undefined;
+
+	return {
+		name,
+		host: raw.host,
+		username: raw.username,
+		port,
+		keyPath,
+		description: raw.description,
+		compat,
+		_source: source,
+	};
+}
+
+function loadSshJsonFile(ctx: LoadContext, path: string): LoadResult<SSHHost> {
+	const items: SSHHost[] = [];
+	const warnings: string[] = [];
+
+	if (!ctx.fs.isFile(path)) {
+		return { items, warnings };
+	}
+
+	const content = ctx.fs.readFile(path);
+	if (content === null) {
+		warnings.push(`Failed to read ${path}`);
+		return { items, warnings };
+	}
+
+	const parsed = parseJSON<SSHConfigFile>(content);
+	if (!parsed) {
+		warnings.push(`Failed to parse JSON in ${path}`);
+		return { items, warnings };
+	}
+
+	const config = expandEnvVarsDeep(parsed);
+	if (!config.hosts || typeof config.hosts !== "object") {
+		warnings.push(`Missing hosts in ${path}`);
+		return { items, warnings };
+	}
+
+	const source = createSourceMeta(PROVIDER_ID, path, "project");
+	for (const [name, rawHost] of Object.entries(config.hosts)) {
+		if (!name.trim()) {
+			warnings.push(`Invalid SSH host name in ${path}`);
+			continue;
+		}
+		if (!rawHost || typeof rawHost !== "object") {
+			warnings.push(`Invalid host entry in ${path}: ${name}`);
+			continue;
+		}
+		const host = normalizeHost(name, rawHost, source, ctx.home, warnings);
+		if (host) items.push(host);
+	}
+
+	return {
+		items,
+		warnings: warnings.length > 0 ? warnings : undefined,
+	};
+}
+
+function load(ctx: LoadContext): LoadResult<SSHHost> {
+	const allItems: SSHHost[] = [];
+	const allWarnings: string[] = [];
+
+	for (const filename of ["ssh.json", ".ssh.json"]) {
+		const path = join(ctx.cwd, filename);
+		const result = loadSshJsonFile(ctx, path);
+		allItems.push(...result.items);
+		if (result.warnings) allWarnings.push(...result.warnings);
+	}
+
+	return {
+		items: allItems,
+		warnings: allWarnings.length > 0 ? allWarnings : undefined,
+	};
+}
+
+registerProvider(sshCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load SSH hosts from ssh.json or .ssh.json in the project root",
+	priority: 5,
+	load,
+});

package/src/main.ts

@@ -7,7 +7,7 @@
 
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
+import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
 import chalk from "chalk";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
@@ -289,6 +289,9 @@ async function buildSessionOptions(
 			process.exit(1);
 		}
 		options.model = model;
+		settingsManager.applyOverrides({
+			modelRoles: { default: `${model.provider}/${model.id}` },
+		});
 	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
 		options.model = scopedModels[0].model;
 	}

package/src/modes/interactive/components/assistant-message.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../theme/theme";
 

package/src/modes/interactive/components/custom-message.ts

@@ -1,4 +1,4 @@
-import type { TextContent } from "@mariozechner/pi-ai";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Box, Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { MessageRenderer } from "../../../core/extensions/types";

package/src/modes/interactive/components/footer.ts

@@ -1,5 +1,5 @@
 import { existsSync, type FSWatcher, readFileSync, watch } from "node:fs";
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { dirname, join } from "path";
 import type { AgentSession } from "../../../core/agent-session";

package/src/modes/interactive/components/hook-message.ts

@@ -1,4 +1,4 @@
-import type { TextContent } from "@mariozechner/pi-ai";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Box, Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { HookMessageRenderer } from "../../../core/hooks/types";

package/src/modes/interactive/components/model-selector.ts

@@ -1,4 +1,4 @@
-import { type Model, modelsAreEqual } from "@mariozechner/pi-ai";
+import { type Model, modelsAreEqual } from "@oh-my-pi/pi-ai";
 import {
 	Container,
 	Input,

package/src/modes/interactive/components/oauth-selector.ts

@@ -1,4 +1,4 @@
-import { getOAuthProviders, type OAuthProviderInfo } from "@mariozechner/pi-ai";
+import { getOAuthProviders, type OAuthProviderInfo } from "@oh-my-pi/pi-ai";
 import { Container, isArrowDown, isArrowUp, isCtrlC, isEnter, isEscape, Spacer, TruncatedText } from "@oh-my-pi/pi-tui";
 import type { AuthStorage } from "../../../core/auth-storage";
 import { theme } from "../theme/theme";

package/src/modes/interactive/components/status-line.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { type FSWatcher, watch } from "fs";
 import { dirname, join } from "path";

package/src/modes/interactive/components/tool-execution.ts

@@ -369,20 +369,23 @@ export class ToolExecutionComponent extends Container {
 			this.contentBox.setBgFn(bgFn);
 			this.contentBox.clear();
 
-			// Render call component
-			try {
-				const callComponent = renderer.renderCall(this.args, theme);
-				if (callComponent) {
-					// Ensure component has invalidate() method for Component interface
-					const component = callComponent as any;
-					if (!component.invalidate) {
-						component.invalidate = () => {};
+			const shouldRenderCall = !this.result || !renderer.mergeCallAndResult;
+			if (shouldRenderCall) {
+				// Render call component
+				try {
+					const callComponent = renderer.renderCall(this.args, theme);
+					if (callComponent) {
+						// Ensure component has invalidate() method for Component interface
+						const component = callComponent as any;
+						if (!component.invalidate) {
+							component.invalidate = () => {};
+						}
+						this.contentBox.addChild(component);
 					}
-					this.contentBox.addChild(component);
+				} catch {
+					// Fall back to default on error
+					this.contentBox.addChild(new Text(theme.fg("toolTitle", theme.bold(this.toolLabel)), 0, 0));
 				}
-			} catch {
-				// Fall back to default on error
-				this.contentBox.addChild(new Text(theme.fg("toolTitle", theme.bold(this.toolLabel)), 0, 0));
 			}
 
 			// Render result component if we have a result