@howaboua/pi-codex-conversion 1.0.9 → 1.0.11

package/src/tools/exec-command-tool.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Text } from "@mariozechner/pi-tui";
-import { renderExecCommandCall } from "./codex-rendering.ts";
+import { Container, Text } from "@mariozechner/pi-tui";
+import { renderExecCommandCall, renderGroupedExecCommandCall } from "./codex-rendering.ts";
 import type { ExecCommandTracker } from "./exec-command-state.ts";
 import type { ExecSessionManager, UnifiedExecResult } from "./exec-session-manager.ts";
 import { formatUnifiedExecResult } from "./unified-exec-format.ts";
@@ -56,6 +56,62 @@ function isUnifiedExecResult(details: unknown): details is UnifiedExecResult {
 	return typeof details === "object" && details !== null;
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
+interface ExecCommandRenderContextLike {
+	toolCallId?: string;
+	invalidate?: () => void;
+}
+
+const renderExecCommandCallWithOptionalContext: any = (
+	args: { cmd?: unknown },
+	theme: { fg(role: string, text: string): string; bold(text: string): string },
+	context: ExecCommandRenderContextLike | undefined,
+	tracker: ExecCommandTracker,
+) => {
+	const command = typeof args.cmd === "string" ? args.cmd : "";
+	tracker.registerRenderContext(context?.toolCallId, context?.invalidate ?? (() => {}));
+	const renderInfo = tracker.getRenderInfo(context?.toolCallId, command);
+	if (renderInfo.hidden) {
+		return new Text("", 0, 0);
+	}
+	const text = renderInfo.actionGroups
+		? renderGroupedExecCommandCall(renderInfo.actionGroups, renderInfo.status, theme)
+		: renderExecCommandCall(command, renderInfo.status, theme);
+	return new Text(text, 0, 0);
+};
+
+const renderExecCommandResultWithOptionalContext: any = (
+	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+	options: { expanded: boolean; isPartial: boolean },
+	theme: { fg(role: string, text: string): string },
+	context: ExecCommandRenderContextLike | undefined,
+	tracker: ExecCommandTracker,
+) => {
+	if (options.isPartial || !options.expanded) {
+		return createEmptyResultComponent();
+	}
+
+	const command = context && "args" in context && context.args && typeof (context as any).args.cmd === "string" ? (context as any).args.cmd : undefined;
+	if (tracker.getRenderInfo(context?.toolCallId, command ?? "").hidden) {
+		return createEmptyResultComponent();
+	}
+
+	const details = isUnifiedExecResult(result.details) ? result.details : undefined;
+	const content = result.content.find((item) => item.type === "text");
+	const output = details?.output ?? (content?.type === "text" ? content.text : "");
+	let text = theme.fg("dim", output || "(no output)");
+	if (details?.session_id !== undefined) {
+		text += `\n${theme.fg("accent", `Session ${details.session_id} still running`)}`;
+	}
+	if (details?.exit_code !== undefined) {
+		text += `\n${theme.fg("muted", `Exit code: ${details.exit_code}`)}`;
+	}
+	return new Text(text, 0, 0);
+};
+
 export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTracker, sessions: ExecSessionManager): void {
 	pi.registerTool({
 		name: "exec_command",
@@ -65,43 +121,31 @@ export function registerExecCommandTool(pi: ExtensionAPI, tracker: ExecCommandTr
 		promptGuidelines: [
 			"Use exec_command for search, listing files, and local text-file reads.",
 			"Prefer rg or rg --files when possible.",
+			"For short or non-interactive commands, omit `yield_time_ms` so the default wait can avoid unnecessary follow-up calls.",
 			"Keep tty disabled unless the command truly needs interactive terminal behavior.",
 		],
 		parameters: EXEC_COMMAND_PARAMETERS,
-		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+		async execute(toolCallId, params, signal, _onUpdate, ctx) {
 			if (signal?.aborted) {
 				throw new Error("exec_command aborted");
 			}
 			const typedParams = parseExecCommandParams(params);
 			const result = await sessions.exec(typedParams, ctx.cwd, signal);
 			if (result.session_id !== undefined) {
-				tracker.recordPersistentSession(typedParams.cmd);
+				tracker.recordPersistentSession(toolCallId, result.session_id);
 			}
 			return {
 				content: [{ type: "text", text: formatUnifiedExecResult(result, typedParams.cmd) }],
 				details: result,
 			};
 		},
-		renderCall(args, theme) {
-			const command = typeof args.cmd === "string" ? args.cmd : "";
-			return new Text(renderExecCommandCall(command, tracker.getState(command), theme), 0, 0);
-		},
-		renderResult(result, { expanded, isPartial }, theme) {
-			if (isPartial || !expanded) {
-				return undefined;
-			}
-
-			const details = isUnifiedExecResult(result.details) ? result.details : undefined;
-			const content = result.content.find((item) => item.type === "text");
-			const output = details?.output ?? (content?.type === "text" ? content.text : "");
-			let text = theme.fg("dim", output || "(no output)");
-			if (details?.session_id !== undefined) {
-				text += `\n${theme.fg("accent", `Session ${details.session_id} still running`)}`;
-			}
-			if (details?.exit_code !== undefined) {
-				text += `\n${theme.fg("muted", `Exit code: ${details.exit_code}`)}`;
-			}
-			return new Text(text, 0, 0);
-		},
+		renderCall: ((args: { cmd?: unknown }, theme: { fg(role: string, text: string): string; bold(text: string): string }, context?: ExecCommandRenderContextLike) =>
+			renderExecCommandCallWithOptionalContext(args, theme, context, tracker)) as any,
+		renderResult: ((
+			result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+			options: { expanded: boolean; isPartial: boolean },
+			theme: { fg(role: string, text: string): string },
+			context?: ExecCommandRenderContextLike,
+		) => renderExecCommandResultWithOptionalContext(result, options, theme, context, tracker)) as any,
 	});
 }

package/src/tools/exec-session-manager.ts

@@ -65,10 +65,19 @@ export interface ExecSessionManager {
 	shutdown(): void;
 }
 
+export interface ExecSessionManagerOptions {
+	defaultExecYieldTimeMs?: number;
+	defaultWriteYieldTimeMs?: number;
+	minNonInteractiveExecYieldTimeMs?: number;
+	minEmptyWriteYieldTimeMs?: number;
+}
+
 const DEFAULT_EXEC_YIELD_TIME_MS = 10_000;
-const DEFAULT_WRITE_YIELD_TIME_MS = 10_000;
+const DEFAULT_WRITE_YIELD_TIME_MS = 250;
 const DEFAULT_MAX_OUTPUT_TOKENS = 10_000;
 const MIN_YIELD_TIME_MS = 250;
+const MIN_NON_INTERACTIVE_EXEC_YIELD_TIME_MS = 5_000;
+const MIN_EMPTY_WRITE_YIELD_TIME_MS = 5_000;
 const MAX_YIELD_TIME_MS = 30_000;
 const MAX_COMMAND_HISTORY = 256;
 
@@ -139,6 +148,32 @@ function clampYieldTime(yieldTimeMs: number | undefined, fallback: number): numb
 	return Math.min(MAX_YIELD_TIME_MS, Math.max(MIN_YIELD_TIME_MS, value));
 }
 
+function clampExecYieldTime(
+	yieldTimeMs: number | undefined,
+	fallback: number,
+	isInteractive: boolean,
+	minNonInteractiveExecYieldTimeMs: number,
+): number {
+	const value = clampYieldTime(yieldTimeMs, fallback);
+	if (isInteractive) {
+		return value;
+	}
+	return Math.min(MAX_YIELD_TIME_MS, Math.max(minNonInteractiveExecYieldTimeMs, value));
+}
+
+function clampWriteYieldTime(
+	yieldTimeMs: number | undefined,
+	fallback: number,
+	isEmptyPoll: boolean,
+	minEmptyWriteYieldTimeMs: number,
+): number {
+	const value = clampYieldTime(yieldTimeMs, fallback);
+	if (!isEmptyPoll) {
+		return value;
+	}
+	return Math.min(MAX_YIELD_TIME_MS, Math.max(minEmptyWriteYieldTimeMs, value));
+}
+
 function maxCharsForTokens(maxOutputTokens = DEFAULT_MAX_OUTPUT_TOKENS): number {
 	return Math.max(256, maxOutputTokens * 4);
 }
@@ -309,11 +344,21 @@ function registerAbortHandler(signal: AbortSignal | undefined, onAbort: () => vo
 	return () => signal.removeEventListener("abort", abortListener);
 }
 
-export function createExecSessionManager(): ExecSessionManager {
+export function createExecSessionManager(options: ExecSessionManagerOptions = {}): ExecSessionManager {
 	let nextSessionId = 1;
 	const sessions = new Map<number, ExecSession>();
 	const commandHistory = new Map<number, string>();
 	const exitListeners = new Set<(sessionId: number, command: string) => void>();
+	const defaultExecYieldTimeMs = options.defaultExecYieldTimeMs ?? DEFAULT_EXEC_YIELD_TIME_MS;
+	const defaultWriteYieldTimeMs = options.defaultWriteYieldTimeMs ?? DEFAULT_WRITE_YIELD_TIME_MS;
+	const minNonInteractiveExecYieldTimeMs = Math.min(
+		MAX_YIELD_TIME_MS,
+		Math.max(MIN_YIELD_TIME_MS, options.minNonInteractiveExecYieldTimeMs ?? MIN_NON_INTERACTIVE_EXEC_YIELD_TIME_MS),
+	);
+	const minEmptyWriteYieldTimeMs = Math.min(
+		MAX_YIELD_TIME_MS,
+		Math.max(MIN_YIELD_TIME_MS, options.minEmptyWriteYieldTimeMs ?? MIN_EMPTY_WRITE_YIELD_TIME_MS),
+	);
 
 	function rememberCommand(sessionId: number, command: string): void {
 		commandHistory.set(sessionId, command);
@@ -494,7 +539,10 @@ export function createExecSessionManager(): ExecSessionManager {
 			sessions.set(session.id, session);
 			rememberCommand(session.id, session.command);
 
-			const waitedMs = await waitForExitOrTimeout(session, clampYieldTime(input.yield_time_ms, DEFAULT_EXEC_YIELD_TIME_MS));
+			const waitedMs = await waitForExitOrTimeout(
+				session,
+				clampExecYieldTime(input.yield_time_ms, defaultExecYieldTimeMs, session.interactive, minNonInteractiveExecYieldTimeMs),
+			);
 			return makeResult(session, waitedMs, input.max_output_tokens);
 		},
 		write: async (input) => {
@@ -512,7 +560,15 @@ export function createExecSessionManager(): ExecSessionManager {
 			}
 			const waitedMs =
 				session.exitCode === undefined
-					? await waitForExitOrTimeout(session, clampYieldTime(input.yield_time_ms, DEFAULT_WRITE_YIELD_TIME_MS))
+					? await waitForExitOrTimeout(
+							session,
+							clampWriteYieldTime(
+								input.yield_time_ms,
+								defaultWriteYieldTimeMs,
+								!input.chars || input.chars.length === 0,
+								minEmptyWriteYieldTimeMs,
+							),
+						)
 					: 0;
 			return makeResult(session, waitedMs, input.max_output_tokens);
 		},

package/src/tools/web-search-tool.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Box, Text } from "@mariozechner/pi-tui";
+import { Box, Container, Text } from "@mariozechner/pi-tui";
 import { isOpenAICodexModel } from "../adapter/codex-model.ts";
 
 export const WEB_SEARCH_UNSUPPORTED_MESSAGE = "web_search is only available with the openai-codex provider";
@@ -56,6 +56,10 @@ function isWebSearchFunctionTool(tool: unknown): tool is FunctionToolPayload {
 	return !!tool && typeof tool === "object" && (tool as FunctionToolPayload).type === "function" && (tool as FunctionToolPayload).name === "web_search";
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
 export function rewriteNativeWebSearchTool(payload: unknown, model: ExtensionContext["model"]): unknown {
 	if (!supportsNativeWebSearch(model) || !payload || typeof payload !== "object") {
 		return payload;
@@ -113,7 +117,7 @@ export function createWebSearchTool(): ToolDefinition<typeof WEB_SEARCH_PARAMETE
 		},
 		renderResult(result, { expanded }, theme) {
 			if (!expanded) {
-				return undefined;
+				return createEmptyResultComponent();
 			}
 			const textBlock = result.content.find((item) => item.type === "text");
 			const text = textBlock?.type === "text" ? textBlock.text : "(no output)";

package/src/tools/write-stdin-tool.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "@sinclair/typebox";
-import { Text } from "@mariozechner/pi-tui";
+import { Container, Text } from "@mariozechner/pi-tui";
 import { renderWriteStdinCall } from "./codex-rendering.ts";
 import type { ExecSessionManager, UnifiedExecResult } from "./exec-session-manager.ts";
 import { formatUnifiedExecResult } from "./unified-exec-format.ts";
@@ -100,12 +100,20 @@ function isUnifiedExecResult(details: unknown): details is UnifiedExecResult {
 	return typeof details === "object" && details !== null;
 }
 
+function createEmptyResultComponent(): Container {
+	return new Container();
+}
+
 export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionManager): void {
 	pi.registerTool({
 		name: "write_stdin",
 		label: "write_stdin",
 		description: "Writes characters to an existing unified exec session and returns recent output.",
 		promptSnippet: "Write to an exec session.",
+		promptGuidelines: [
+			"Use empty `chars` only to poll a running exec session.",
+			"When polling with empty `chars`, wait meaningfully between polls and do not repeatedly poll by reflex.",
+		],
 		parameters: WRITE_STDIN_PARAMETERS,
 		async execute(_toolCallId, params) {
 			const typed = parseWriteStdinParams(params);
@@ -129,7 +137,7 @@ export function registerWriteStdinTool(pi: ExtensionAPI, sessions: ExecSessionMa
 			return new Text(renderWriteStdinCall(sessionId, input, command, theme), 0, 0);
 		},
 		renderResult(result, { expanded, isPartial }, theme) {
-			if (isPartial || !expanded) return undefined;
+			if (isPartial || !expanded) return createEmptyResultComponent();
 			const state = getResultState(result);
 			const output = renderTerminalText(state.output);
 			let text = theme.fg("dim", output || "(no output)");