@oh-my-pi/pi-coding-agent 14.9.9 → 15.0.1

package/src/eval/js/shared/rewrite-imports.ts

@@ -1,9 +1,10 @@
 import { parse as babelParse } from "@babel/parser";
 
-// Static ESM `import` declarations are not valid inside vm.runInContext (script-mode parsing).
-// We rewrite top-level imports to dynamic-import expressions in the user-supplied source so
-// pasted ESM runs verbatim. A real parser keeps imports embedded in string literals, template
-// literals, or comments intact.
+// Static ESM `import` declarations are not valid inside vm.runInContext (script-mode parsing),
+// and dynamic `import(...)` would otherwise resolve specifiers against the worker module's URL
+// instead of the session cwd. We rewrite both forms so they route through the worker-injected
+// `__omp_import__` helper, which resolves the specifier against the active session cwd. A real
+// parser keeps imports embedded in string literals, template literals, or comments intact.
 
 type BabelImportDeclaration = {
 	type: "ImportDeclaration";
@@ -25,26 +26,78 @@ type BabelLexicalDecl =
 	| { type: "VariableDeclaration"; kind: "const" | "let" | "var"; start: number; end: number }
 	| { type: "ClassDeclaration"; start: number; end: number; id: { start: number; end: number; name: string } | null };
 
-function buildDynamicImportCall(sourceLiteral: string, withClause: string | undefined): string {
+type BabelExpressionStatement = {
+	type: "ExpressionStatement";
+	start: number;
+	end: number;
+	expression?: { type?: string };
+};
+
+type BabelProgramNode = BabelImportDeclaration | BabelLexicalDecl | BabelExpressionStatement | { type: string };
+
+type BabelNode = { type: string; start: number; end: number; [key: string]: unknown };
+
+function parseProgram(code: string): { program: { body: ReadonlyArray<BabelProgramNode> } } | null {
+	try {
+		return babelParse(code, {
+			sourceType: "module",
+			allowAwaitOutsideFunction: true,
+			allowReturnOutsideFunction: true,
+			allowImportExportEverywhere: true,
+			allowNewTargetOutsideFunction: true,
+			allowSuperOutsideMethod: true,
+			allowUndeclaredExports: true,
+			errorRecovery: true,
+		}) as unknown as { program: { body: ReadonlyArray<BabelProgramNode> } };
+	} catch {
+		return null;
+	}
+}
+
+function buildOmpImportCall(sourceLiteral: string, optionsLiteral: string | undefined): string {
 	// Route every static import through the worker-injected `__omp_import__` helper so the
 	// specifier resolves against the session cwd (and `with`-attribute imports keep working).
-	return withClause ? `__omp_import__(${sourceLiteral}, ${withClause})` : `__omp_import__(${sourceLiteral})`;
+	return optionsLiteral ? `__omp_import__(${sourceLiteral}, ${optionsLiteral})` : `__omp_import__(${sourceLiteral})`;
 }
 
-function buildWithClause(node: BabelImportDeclaration): string | undefined {
+// Walks every node in `root`, depth-first, invoking `visit` on each one. Skips Babel's
+// non-AST bookkeeping fields so we don't recurse into source locations or comment arrays.
+function walkNodes(root: unknown, visit: (node: BabelNode) => void): void {
+	const stack: unknown[] = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || typeof current !== "object") continue;
+		if (Array.isArray(current)) {
+			for (let i = current.length - 1; i >= 0; i--) stack.push(current[i]);
+			continue;
+		}
+		const node = current as Record<string, unknown>;
+		if (typeof node.type === "string") visit(node as unknown as BabelNode);
+		for (const key in node) {
+			if (key === "loc" || key === "extra" || key === "range") continue;
+			if (key === "leadingComments" || key === "trailingComments" || key === "innerComments") continue;
+			const value = node[key];
+			if (value && typeof value === "object") stack.push(value);
+		}
+	}
+}
+
+function buildOptionsLiteral(node: BabelImportDeclaration): string | undefined {
 	const attrs = node.attributes;
 	if (!attrs || attrs.length === 0) return undefined;
 	const pairs = attrs.map(attr => {
 		const key = attr.key.type === "Identifier" ? attr.key.name : JSON.stringify(attr.key.value);
 		return `${key}: ${JSON.stringify(attr.value.value)}`;
 	});
-	return `{ ${pairs.join(", ")} }`;
+	// Native dynamic import takes options as `{ with: { ... } }`. `__omp_import__` forwards the
+	// options bag verbatim, so we wrap the attribute pairs accordingly.
+	return `{ with: { ${pairs.join(", ")} } }`;
 }
 
 function rewriteImportNode(node: BabelImportDeclaration): string {
 	const sourceLiteral = JSON.stringify(node.source.value);
-	const withClause = buildWithClause(node);
-	const importCall = buildDynamicImportCall(sourceLiteral, withClause);
+	const optionsLiteral = buildOptionsLiteral(node);
+	const importCall = buildOmpImportCall(sourceLiteral, optionsLiteral);
 
 	let defaultName: string | undefined;
 	let namespaceName: string | undefined;
@@ -73,37 +126,43 @@ function rewriteImportNode(node: BabelImportDeclaration): string {
 	return `await ${importCall};`;
 }
 
-export function rewriteStaticImports(code: string): string {
+export function rewriteImports(code: string): string {
 	if (!code.includes("import")) return code;
 
-	let ast: { program: { body: ReadonlyArray<{ type: string }> } };
-	try {
-		ast = babelParse(code, {
-			sourceType: "module",
-			allowAwaitOutsideFunction: true,
-			allowReturnOutsideFunction: true,
-			allowImportExportEverywhere: true,
-			allowNewTargetOutsideFunction: true,
-			allowSuperOutsideMethod: true,
-			allowUndeclaredExports: true,
-			errorRecovery: true,
-		}) as unknown as typeof ast;
-	} catch {
+	const ast = parseProgram(code);
+	if (!ast) {
 		// Parser bailed entirely — let the VM surface the real syntax error.
 		return code;
 	}
 
-	const imports: BabelImportDeclaration[] = [];
+	type Edit = { start: number; end: number; text: string };
+	const edits: Edit[] = [];
+
+	// Top-level static `import` declarations become `await __omp_import__(...)` calls.
 	for (const node of ast.program.body) {
-		if (node.type === "ImportDeclaration") imports.push(node as unknown as BabelImportDeclaration);
+		if (node.type !== "ImportDeclaration") continue;
+		const decl = node as unknown as BabelImportDeclaration;
+		edits.push({ start: decl.start, end: decl.end, text: rewriteImportNode(decl) });
 	}
-	if (imports.length === 0) return code;
+
+	// Dynamic `import(...)` expressions (anywhere) get their callee swapped for `__omp_import__`
+	// so the specifier resolves against the session cwd instead of the worker module's URL.
+	walkNodes(ast, node => {
+		if (node.type !== "CallExpression") return;
+		const call = node as unknown as { callee?: { type?: string; start?: number; end?: number } };
+		const callee = call.callee;
+		if (!callee || callee.type !== "Import" || typeof callee.start !== "number" || typeof callee.end !== "number")
+			return;
+		edits.push({ start: callee.start, end: callee.end, text: "__omp_import__" });
+	});
+
+	if (edits.length === 0) return code;
 
 	// Splice from the back so earlier offsets stay valid.
-	imports.sort((a, b) => b.start - a.start);
+	edits.sort((a, b) => b.start - a.start);
 	let result = code;
-	for (const node of imports) {
-		result = result.slice(0, node.start) + rewriteImportNode(node) + result.slice(node.end);
+	for (const edit of edits) {
+		result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
 	}
 	return result;
 }
@@ -121,22 +180,11 @@ export function rewriteStaticImports(code: string): string {
  * Nested declarations (inside functions, blocks, classes) are left alone \u2014 they're
  * scoped to their enclosing function/block regardless of `var` vs `let`/`const`.
  */
-export function demoteTopLevelLexicals(code: string): string {
+function demoteTopLevelLexicals(code: string): string {
 	if (!/\b(?:const|let|class)\b/.test(code)) return code;
 
-	let ast: { program: { body: ReadonlyArray<{ type: string }> } };
-	try {
-		ast = babelParse(code, {
-			sourceType: "module",
-			allowAwaitOutsideFunction: true,
-			allowReturnOutsideFunction: true,
-			allowImportExportEverywhere: true,
-			allowNewTargetOutsideFunction: true,
-			allowSuperOutsideMethod: true,
-			allowUndeclaredExports: true,
-			errorRecovery: true,
-		}) as unknown as typeof ast;
-	} catch {
+	const ast = parseProgram(code);
+	if (!ast) {
 		return code;
 	}
 
@@ -172,6 +220,24 @@ export function demoteTopLevelLexicals(code: string): string {
 	return result;
 }
 
+function returnFinalExpression(code: string): { source: string; returned: boolean } {
+	const ast = parseProgram(code);
+	const body = ast?.program.body;
+	if (!body) return { source: code, returned: false };
+	let lastIndex = body.length - 1;
+	while (lastIndex >= 0 && body[lastIndex]?.type === "EmptyStatement") lastIndex--;
+	const last = lastIndex >= 0 ? body[lastIndex] : undefined;
+	if (last?.type !== "ExpressionStatement") return { source: code, returned: false };
+
+	const expression = last as BabelExpressionStatement;
+	const prefix = code.slice(0, expression.start);
+	const statement = code.slice(expression.start, expression.end);
+	const suffix = code.slice(expression.end);
+	const semicolonMatch = statement.match(/;\s*$/);
+	const trimmedStatement = semicolonMatch ? statement.slice(0, semicolonMatch.index) : statement;
+	return { source: `${prefix}__omp_set_final_expr__((${trimmedStatement}));${suffix}`, returned: true };
+}
+
 /**
  * Strip TypeScript syntax (type annotations, `interface`, `as`, `satisfies`, generics in
  * call expressions, etc.) before the import/lexical rewriters parse the code. We use Bun's
@@ -182,7 +248,7 @@ export function demoteTopLevelLexicals(code: string): string {
  * common case avoids an extra transpile pass. We detect "looks like TS" with a cheap regex
  * before invoking the transpiler.
  */
-export function stripTypeScript(code: string): string {
+function stripTypeScript(code: string): string {
 	if (!LOOKS_LIKE_TS.test(code)) return code;
 	try {
 		return new Bun.Transpiler({ loader: "ts" }).transformSync(code);
@@ -198,14 +264,20 @@ export function stripTypeScript(code: string): string {
 const LOOKS_LIKE_TS =
 	/(?:\binterface\s+\w|\btype\s+\w+\s*=|\b(?:as|satisfies)\s+(?:[A-Z]|\bconst\b)|:\s*(?:string|number|boolean|any|unknown|void|never|object|[A-Z]\w*)\b|<\s*[A-Z]\w*\s*[,>])/;
 
-export function wrapCode(code: string): { source: string; asyncWrapped: boolean } {
-	const rewritten = demoteTopLevelLexicals(rewriteStaticImports(stripTypeScript(code)));
-	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(rewritten);
+export function wrapCode(code: string): { source: string; asyncWrapped: boolean; finalExpressionReturned: boolean } {
+	const stripped = stripTypeScript(code);
+	const finalExpression = returnFinalExpression(stripped);
+	const rewritten = {
+		source: demoteTopLevelLexicals(rewriteImports(finalExpression.source)),
+		returned: finalExpression.returned,
+	};
+	const needsAsyncWrapper = /\bawait\b|\breturn\b/.test(rewritten.source);
 	if (!needsAsyncWrapper) {
-		return { source: rewritten, asyncWrapped: false };
+		return { source: rewritten.source, asyncWrapped: false, finalExpressionReturned: rewritten.returned };
 	}
 	return {
-		source: `(async () => {\n${rewritten}\n})()`,
+		source: `(async () => {\n${rewritten.source}\n})()`,
 		asyncWrapped: true,
+		finalExpressionReturned: rewritten.returned,
 	};
 }

package/src/eval/js/shared/runtime.ts

@@ -4,6 +4,8 @@ import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import * as util from "node:util";
 
+import { logger } from "@oh-my-pi/pi-utils";
+
 import { ToolError } from "../../../tools/tool-errors";
 import { createHelpers, type HelperBundle } from "./helpers";
 import { awaitMaybePromise, indirectEval } from "./indirect-eval";
@@ -48,6 +50,8 @@ export class JsRuntime {
 	readonly sessionId: string;
 	#env: Map<string, string>;
 	#getHooks: () => RuntimeHooks | null;
+	#finalExpressionSet = false;
+	#finalExpressionValue: unknown;
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
@@ -82,8 +86,20 @@ export class JsRuntime {
 	}
 
 	async run(code: string, filename?: string): Promise<unknown> {
+		this.#finalExpressionSet = false;
+		this.#finalExpressionValue = undefined;
 		const wrapped = wrapCode(code);
 		const value = indirectEval(wrapped.source, filename);
+		if (wrapped.finalExpressionReturned) {
+			const awaited = await awaitMaybePromise(value);
+			if (this.#finalExpressionSet) {
+				const finalValue = this.#finalExpressionValue;
+				this.#finalExpressionSet = false;
+				this.#finalExpressionValue = undefined;
+				return await awaitMaybePromise(finalValue);
+			}
+			return awaited;
+		}
 		return await awaitMaybePromise(value);
 	}
 
@@ -97,7 +113,14 @@ export class JsRuntime {
 				hooks.onDisplay({ type: "image", data: record.data, mimeType: record.mimeType });
 				return;
 			}
-			hooks.onDisplay({ type: "json", data: structuredClone(value) });
+			try {
+				hooks.onDisplay({ type: "json", data: structuredClone(value) });
+			} catch (err) {
+				logger.debug("js displayValue: value is not structured-cloneable, falling back to text", {
+					error: err instanceof Error ? err.message : String(err),
+				});
+				hooks.onText(`${Object.prototype.toString.call(value)}\n`);
+			}
 			return;
 		}
 		hooks.onText(`${String(value)}\n`);
@@ -112,9 +135,9 @@ export class JsRuntime {
 				if (!hooks) throw new ToolError("Tool calls are only valid inside an active run");
 				return await hooks.callTool(name, args);
 			},
-			__omp_import__: async (source: string, attrs?: Record<string, string>) => {
+			__omp_import__: async (source: string, options?: ImportCallOptions) => {
 				const target = resolveImportSpecifier(this.#cwd, source);
-				return attrs ? await import(target, { with: attrs }) : await import(target);
+				return options !== undefined ? await import(target, options) : await import(target);
 			},
 			__omp_emit_status__: (op: string, data: Record<string, unknown> = {}) => {
 				const event: JsStatusEvent = { op, ...data };
@@ -126,6 +149,10 @@ export class JsRuntime {
 				this.#getHooks()?.onText(text.endsWith("\n") ? text : `${text}\n`);
 			},
 			__omp_display__: (value: unknown) => this.displayValue(value),
+			__omp_set_final_expr__: (value: unknown) => {
+				this.#finalExpressionSet = true;
+				this.#finalExpressionValue = value;
+			},
 			webcrypto: crypto,
 			// `process` is intentionally not overridden — user code gets the host worker's real
 			// `process` object. Subsetting it caused segfaults in workers that share state with
@@ -152,7 +179,7 @@ function buildRequire(cwd: string): NodeJS.Require {
 }
 
 /**
- * Resolve an import specifier emitted by `rewriteStaticImports` against the active session
+ * Resolve an import specifier emitted by `rewriteImports` against the active session
  * cwd. Relative paths (`./`, `../`, `/`) and bare specifiers (`pkg`, `@scope/pkg`) both go
  * through `Bun.resolveSync` rooted at the cwd so user-pasted ESM behaves as if it lived in
  * the project — not next to the worker module. URL-like specifiers (`file://`, `data:`,

package/src/eval/js/tool-bridge.ts

@@ -17,7 +17,17 @@ type ToolValue =
 			text: string;
 			details?: unknown;
 			images?: Array<{ mimeType: string; data: string }>;
+			hasError?: boolean;
 	  };
+function toolResultHasError(result: AgentToolResult): boolean {
+	if ((result as { isError?: unknown }).isError === true) {
+		return true;
+	}
+	if (!(result.details && typeof result.details === "object")) {
+		return false;
+	}
+	return (result.details as { isError?: unknown }).isError === true;
+}
 
 function getTool(session: ToolSession, name: string): AgentTool {
 	const tool = session.getToolByName?.(name);
@@ -38,7 +48,13 @@ function normalizeArgs(args: unknown): unknown {
 	return record;
 }
 
-function summarizeToolResult(name: string, args: unknown, result: AgentToolResult, text: string): JsStatusEvent {
+function summarizeToolResult(
+	name: string,
+	args: unknown,
+	result: AgentToolResult,
+	text: string,
+	hasError: boolean,
+): JsStatusEvent {
 	const record = (args && typeof args === "object" ? (args as Record<string, unknown>) : {}) as Record<
 		string,
 		unknown
@@ -46,39 +62,41 @@ function summarizeToolResult(name: string, args: unknown, result: AgentToolResul
 	const details = (
 		result.details && typeof result.details === "object" ? (result.details as Record<string, unknown>) : {}
 	) as Record<string, unknown>;
+	const withError = (event: JsStatusEvent): JsStatusEvent =>
+		hasError ? { ...event, hasError: true, error: text.slice(0, 500) } : event;
 
 	switch (name) {
 		case "read":
-			return { op: "read", path: record.path, chars: text.length, preview: text.slice(0, 500) };
+			return withError({ op: "read", path: record.path, chars: text.length, preview: text.slice(0, 500) });
 		case "write":
-			return {
+			return withError({
 				op: "write",
 				path: record.path,
 				chars: typeof record.content === "string" ? record.content.length : 0,
-			};
+			});
 		case "grep":
-			return {
+			return withError({
 				op: "grep",
 				pattern: record.pattern,
 				path: record.path,
 				count: details.matchCount ?? undefined,
-			};
+			});
 		case "find":
-			return {
+			return withError({
 				op: "find",
 				pattern: record.pattern,
 				count: details.fileCount ?? undefined,
 				matches: Array.isArray(details.files) ? details.files.slice(0, 20) : undefined,
-			};
+			});
 		case "bash":
-			return {
+			return withError({
 				op: "run",
 				cmd: record.command,
 				code: typeof details.exitCode === "number" ? details.exitCode : undefined,
 				output: text.slice(0, 500),
-			};
+			});
 		default:
-			return { op: name, chars: text.length };
+			return withError({ op: name, chars: text.length });
 	}
 }
 
@@ -97,21 +115,25 @@ export async function callSessionTool(name: string, args: unknown, options: Tool
 				content.type === "image" && typeof content.mimeType === "string" && typeof content.data === "string",
 		);
 		const text = textBlocks.map(block => block.text).join("");
-		options.emitStatus?.(summarizeToolResult(name, normalizedArgs, result, text));
-		if (result.details === undefined && imageBlocks.length === 0) {
+		const hasError = toolResultHasError(result);
+		options.emitStatus?.(summarizeToolResult(name, normalizedArgs, result, text, hasError));
+		if (result.details === undefined && imageBlocks.length === 0 && !hasError) {
 			return text;
 		}
-		return {
+		const value: Exclude<ToolValue, string> = {
 			text,
 			details: result.details,
-			images:
-				imageBlocks.length > 0
-					? imageBlocks.map(block => ({
-							mimeType: block.mimeType,
-							data: block.data,
-						}))
-					: undefined,
 		};
+		if (imageBlocks.length > 0) {
+			value.images = imageBlocks.map(block => ({
+				mimeType: block.mimeType,
+				data: block.data,
+			}));
+		}
+		if (hasError) {
+			value.hasError = true;
+		}
+		return value;
 	} catch (error) {
 		options.emitStatus?.({
 			op: name,

package/src/eval/py/executor.ts

@@ -1,6 +1,8 @@
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
+import { Settings } from "../../config/settings";
 import { OutputSink } from "../../session/streaming-output";
 import type { ToolSession } from "../../tools";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../../tools/output-meta";
 import type { JsStatusEvent } from "../js/shared/types";
 import type { KernelDisplayOutput } from "./display";
 import {
@@ -815,10 +817,13 @@ async function executeWithKernel(
 	code: string,
 	options: PythonExecutorOptions | undefined,
 ): Promise<PythonResult> {
+	const settings = await Settings.init();
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 	});
 	const displayOutputs: KernelDisplayOutput[] = [];
 	const deadlineMs = getExecutionDeadlineMs(options);

package/src/exa/factory.ts

@@ -3,7 +3,7 @@
  */
 import type { TObject, TProperties } from "@sinclair/typebox";
 import type { CustomTool } from "../extensibility/custom-tools/types";
-import { callExaTool, findApiKey, formatSearchResults, isSearchResponse } from "./mcp-client";
+import { callExaTool, findApiKey, formatGenericResponse, formatSearchResults, isSearchResponse } from "./mcp-client";
 import type { ExaRenderDetails } from "./types";
 
 /** Creates an Exa tool with standardized API key handling, error wrapping, and optional search response formatting. */
@@ -44,7 +44,7 @@ export function createExaTool(
 				}
 
 				return {
-					content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+					content: [{ type: "text" as const, text: formatGenericResponse(response) }],
 					details: { raw: response, toolName: name },
 				};
 			} catch (error) {

package/src/exa/mcp-client.ts

@@ -174,6 +174,79 @@ export function formatSearchResults(data: ExaSearchResponse): string {
 
 	return output.trim();
 }
+/**
+ * Format a non-search MCP response as human-readable text.
+ * Handles objects, arrays, primitives, and common MCP response shapes.
+ */
+export function formatGenericResponse(data: unknown): string {
+	if (data === null || data === undefined) return "No result.";
+	if (typeof data === "string") return data;
+	if (typeof data === "number" || typeof data === "boolean") return String(data);
+
+	if (Array.isArray(data)) {
+		if (data.length === 0) return "(empty)";
+		const parts: string[] = [];
+		for (let i = 0; i < data.length; i++) {
+			const item = data[i];
+			if (typeof item === "object" && item !== null) {
+				const record = item as Record<string, unknown>;
+				const title = (record.title ?? record.name ?? record.id ?? `Item ${i + 1}`) as string;
+				parts.push(`\n### ${title}`);
+				for (const [k, v] of Object.entries(record)) {
+					if (["title", "name", "id"].includes(k)) continue;
+					parts.push(`- **${k}:** ${formatValue(v)}`);
+				}
+			} else {
+				parts.push(`- ${formatValue(item)}`);
+			}
+		}
+		return parts.join("\n");
+	}
+
+	if (typeof data === "object") {
+		const record = data as Record<string, unknown>;
+		if (record.content && Array.isArray(record.content)) {
+			// MCP-style content array — extract text blocks
+			const texts = record.content
+				.filter(
+					(c: unknown): c is { type: string; text?: string } =>
+						typeof c === "object" && c !== null && (c as Record<string, unknown>)?.type === "text",
+				)
+				.map(c => c.text ?? "")
+				.filter(Boolean);
+			if (texts.length > 0) return texts.join("\n");
+		}
+
+		const lines: string[] = [];
+		for (const [k, v] of Object.entries(record)) {
+			if (k === "content") continue; // handled above
+			if (v === null || v === undefined) continue;
+			if (typeof v === "object") {
+				const formatted = formatGenericResponse(v);
+				if (formatted) lines.push(`- **${k}:**\n${indent(formatted, 2)}`);
+			} else {
+				lines.push(`- **${k}:** ${formatValue(v)}`);
+			}
+		}
+		return lines.join("\n") || "(empty)";
+	}
+
+	return String(data);
+}
+
+function formatValue(v: unknown): string {
+	if (v === null || v === undefined) return "—";
+	if (typeof v === "object") return JSON.stringify(v);
+	return String(v);
+}
+
+function indent(text: string, spaces: number): string {
+	const pad = " ".repeat(spaces);
+	return text
+		.split("\n")
+		.map(line => pad + line)
+		.join("\n");
+}
 
 /** Check if result is a search response */
 export function isSearchResponse(data: unknown): data is ExaSearchResponse {
@@ -260,7 +333,7 @@ export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
 			}
 
 			return {
-				content: [{ type: "text" as const, text: JSON.stringify(response, null, 2) }],
+				content: [{ type: "text" as const, text: formatGenericResponse(response) }],
 				details: { raw: response, toolName: this.config.name },
 			};
 		} catch (error) {

package/src/exec/bash-executor.ts

@@ -7,6 +7,7 @@ import * as fs from "node:fs/promises";
 import { executeShell, type MinimizerOptions, Shell } from "@oh-my-pi/pi-natives";
 import { Settings, type ShellMinimizerSettings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 import { NON_INTERACTIVE_ENV } from "./non-interactive-env";
 
@@ -64,7 +65,8 @@ async function resolveShellCwd(cwd: string | undefined): Promise<string | undefi
 	}
 }
 
-function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined {
+/** Translate `ShellMinimizerSettings` into native `MinimizerOptions`, or `undefined` when disabled. */
+export function buildMinimizerOptions(group: ShellMinimizerSettings): MinimizerOptions | undefined {
 	if (!group.enabled) return undefined;
 	return {
 		enabled: true,
@@ -94,6 +96,8 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 		// Throttle the streaming preview callback to avoid saturating the
 		// event loop when commands produce massive output (e.g. seq 1 50M).
 		chunkThrottleMs: options?.onChunk ? 50 : 0,