@oh-my-pi/pi-coding-agent 14.1.1 → 14.2.0

package/src/tools/fetch.ts

@@ -18,7 +18,7 @@ import { ensureTool } from "../utils/tools-manager";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
 import { specialHandlers } from "../web/scrapers";
 import type { RenderResult } from "../web/scrapers/types";
-import { finalizeOutput, loadPage, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
+import { finalizeOutput, loadPage, looksLikeHtml, MAX_OUTPUT_CHARS } from "../web/scrapers/types";
 import { convertWithMarkit, fetchBinary } from "../web/scrapers/utils";
 import { applyListLimit } from "./list-limit";
 import { formatStyledArtifactReference, type OutputMeta } from "./output-meta";
@@ -253,19 +253,6 @@ function isInlineImageMimeTypeSupported(mimeType: string): boolean {
 	return SUPPORTED_INLINE_IMAGE_MIME_TYPES.has(mimeType);
 }
 
-/**
- * Check if content looks like HTML
- */
-function looksLikeHtml(content: string): boolean {
-	const trimmed = content.trim().toLowerCase();
-	return (
-		trimmed.startsWith("<!doctype") ||
-		trimmed.startsWith("<html") ||
-		trimmed.startsWith("<head") ||
-		trimmed.startsWith("<body")
-	);
-}
-
 /**
  * Try fetching URL with .md appended (llms.txt convention)
  */

package/src/tools/file-recorder.ts

@@ -0,0 +1,35 @@
+import * as path from "node:path";
+
+/**
+ * Creates a deduplicating recorder for relative file paths.
+ * Preserves insertion order in `list`; subsequent duplicates are ignored.
+ */
+export function createFileRecorder(): {
+	record: (relativePath: string) => void;
+	list: string[];
+} {
+	const seen = new Set<string>();
+	const list: string[] = [];
+	return {
+		record(relativePath: string) {
+			if (!seen.has(relativePath)) {
+				seen.add(relativePath);
+				list.push(relativePath);
+			}
+		},
+		list,
+	};
+}
+
+/**
+ * Strip a leading slash and, when the search scope is a directory, normalize
+ * Windows-style separators. For single-file scopes, fall back to the basename
+ * so tool output does not leak absolute paths.
+ */
+export function formatResultPath(filePath: string, isDirectory: boolean): string {
+	const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+	if (isDirectory) {
+		return cleanPath.replace(/\\/g, "/");
+	}
+	return path.basename(cleanPath);
+}

package/src/tools/find.ts

@@ -29,9 +29,12 @@ import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 const findSchema = Type.Object({
-	pattern: Type.String({ description: "Glob pattern, e.g. '*.ts', 'src/**/*.json', 'lib/*.tsx'" }),
-	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files and directories (default: true)" })),
-	limit: Type.Optional(Type.Number({ description: "Max results (default: 1000)" })),
+	pattern: Type.String({
+		description:
+			"Glob pattern including the search path (no separate path param), e.g. 'src/**/*.ts', 'lib/*.json'. Supports comma-separated lists like 'apps/,packages/,phases/'. Simple patterns like '*.ts' recurse from cwd.",
+	}),
+	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files and directories", default: true })),
+	limit: Type.Optional(Type.Number({ description: "Max results", default: 1000 })),
 });
 
 export type FindToolInput = Static<typeof findSchema>;

package/src/tools/gh-format.ts

@@ -0,0 +1,12 @@
+/**
+ * Return the first 12 hex characters of a commit SHA, or undefined when the
+ * input is missing. Shared between GitHub tool argument normalization and the
+ * run-watch renderer.
+ */
+export function formatShortSha(value: string | undefined): string | undefined {
+	if (!value) {
+		return undefined;
+	}
+
+	return value.slice(0, 12);
+}

package/src/tools/gh-renderer.ts

@@ -9,6 +9,7 @@ import type {
 	GhRunWatchViewDetails,
 	GhToolDetails,
 } from "./gh";
+import { formatShortSha } from "./gh-format";
 import {
 	formatExpandHint,
 	formatStatusIcon,
@@ -29,14 +30,6 @@ const RUNNING_STATUSES = new Set(["in_progress"]);
 const PENDING_STATUSES = new Set(["queued", "requested", "waiting", "pending"]);
 const FALLBACK_WIDTH = 80;
 
-function formatShortSha(value: string | undefined): string | undefined {
-	if (!value) {
-		return undefined;
-	}
-
-	return value.slice(0, 12);
-}
-
 function getWatchHeader(watch: GhRunWatchViewDetails): string {
 	if (watch.mode === "run" && watch.run) {
 		if (watch.state === "watching") {

package/src/tools/gh.ts

@@ -14,6 +14,7 @@ import ghSearchIssuesDescription from "../prompts/tools/gh-search-issues.md" wit
 import ghSearchPrsDescription from "../prompts/tools/gh-search-prs.md" with { type: "text" };
 import * as git from "../utils/git";
 import type { ToolSession } from ".";
+import { formatShortSha } from "./gh-format";
 import type { OutputMeta } from "./output-meta";
 import { ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -148,7 +149,7 @@ const ghIssueViewSchema = Type.Object({
 	repo: Type.Optional(
 		Type.String({ description: "Repository in OWNER/REPO format. Omit when passing a full issue URL." }),
 	),
-	comments: Type.Optional(Type.Boolean({ description: "Include issue comments (default: true)." })),
+	comments: Type.Optional(Type.Boolean({ description: "Include issue comments.", default: true })),
 });
 
 const ghPrViewSchema = Type.Object({
@@ -161,7 +162,7 @@ const ghPrViewSchema = Type.Object({
 	repo: Type.Optional(
 		Type.String({ description: "Repository in OWNER/REPO format. Omit when passing a full pull request URL." }),
 	),
-	comments: Type.Optional(Type.Boolean({ description: "Include pull request comments (default: true)." })),
+	comments: Type.Optional(Type.Boolean({ description: "Include pull request comments.", default: true })),
 });
 
 const ghPrDiffSchema = Type.Object({
@@ -217,13 +218,13 @@ const ghPrPushSchema = Type.Object({
 const ghSearchIssuesSchema = Type.Object({
 	query: Type.String({ description: "GitHub issue search query. Supports GitHub search syntax." }),
 	repo: Type.Optional(Type.String({ description: "Repository in OWNER/REPO format to scope the search." })),
-	limit: Type.Optional(Type.Number({ description: "Maximum results to return (default: 10, max: 50)." })),
+	limit: Type.Optional(Type.Number({ description: "Maximum results to return (max: 50).", default: 10 })),
 });
 
 const ghSearchPrsSchema = Type.Object({
 	query: Type.String({ description: "GitHub pull request search query. Supports GitHub search syntax." }),
 	repo: Type.Optional(Type.String({ description: "Repository in OWNER/REPO format to scope the search." })),
-	limit: Type.Optional(Type.Number({ description: "Maximum results to return (default: 10, max: 50)." })),
+	limit: Type.Optional(Type.Number({ description: "Maximum results to return (max: 50).", default: 10 })),
 });
 
 const ghRunWatchSchema = Type.Object({
@@ -239,7 +240,7 @@ const ghRunWatchSchema = Type.Object({
 		}),
 	),
 	tail: Type.Optional(
-		Type.Number({ description: "Number of log lines to include per failed job (default: 15, max: 200)." }),
+		Type.Number({ description: "Number of log lines to include per failed job (max: 200).", default: 15 }),
 	),
 });
 
@@ -545,14 +546,6 @@ function normalizeOptionalString(value: string | null | undefined): string | und
 	return normalized ? normalized : undefined;
 }
 
-function formatShortSha(value: string | undefined): string | undefined {
-	if (!value) {
-		return undefined;
-	}
-
-	return value.slice(0, 12);
-}
-
 function requireNonEmpty(value: string | null | undefined, label: string): string {
 	const normalized = normalizeOptionalString(value);
 	if (!normalized) {

package/src/tools/grep.ts

@@ -6,7 +6,6 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { computeLineHash } from "../edit/line-hash";
 import { type ChunkedGrepMatch, describeChunkedGrepMatch } from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
@@ -16,6 +15,8 @@ import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, t
 import { resolveEditMode } from "../utils/edit-mode";
 import { resolveFileDisplayMode } from "../utils/file-display-mode";
 import type { ToolSession } from ".";
+import { createFileRecorder } from "./file-recorder";
+import { formatMatchLine } from "./match-line-format";
 import { formatFullOutputReference, type OutputMeta } from "./output-meta";
 import {
 	combineSearchGlobs,
@@ -34,13 +35,13 @@ const grepSchema = Type.Object({
 	path: Type.Optional(Type.String({ description: "File or directory to search (default: cwd)" })),
 	glob: Type.Optional(Type.String({ description: "Filter files by glob pattern (e.g., '*.js')" })),
 	type: Type.Optional(Type.String({ description: "Filter by file type (e.g., js, py, rust)" })),
-	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search (default: false)" })),
+	i: Type.Optional(Type.Boolean({ description: "Case-insensitive search", default: false })),
 	pre: Type.Optional(Type.Number({ description: "Lines of context before matches" })),
 	post: Type.Optional(Type.Number({ description: "Lines of context after matches" })),
 	multiline: Type.Optional(Type.Boolean({ description: "Enable multiline matching" })),
-	gitignore: Type.Optional(Type.Boolean({ description: "Respect .gitignore files during search (default: true)" })),
-	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches (default: 20)" })),
-	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit (default: 0)" })),
+	gitignore: Type.Optional(Type.Boolean({ description: "Respect .gitignore files during search", default: true })),
+	limit: Type.Optional(Type.Number({ description: "Limit output to first N matches", default: 20 })),
+	offset: Type.Optional(Type.Number({ description: "Skip first N entries before applying limit", default: 0 })),
 });
 
 export type GrepToolInput = Static<typeof grepSchema>;
@@ -243,15 +244,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				? roundRobinSelect(result.matches, effectiveLimit)
 				: result.matches.slice(0, effectiveLimit);
 			const matchLimitReached = result.matches.length > effectiveLimit;
-			const files = new Set<string>();
-			const fileList: string[] = [];
+			const { record: recordFile, list: fileList } = createFileRecorder();
 			const fileMatchCounts = new Map<string, number>();
-			const recordFile = (relativePath: string) => {
-				if (!files.has(relativePath)) {
-					files.add(relativePath);
-					fileList.push(relativePath);
-				}
-			};
 			if (selectedMatches.length === 0) {
 				const details: GrepToolDetails = {
 					scopePath,
@@ -401,15 +395,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						}
 					}
 					const lineWidth = Math.max(...lineNumbers.map(value => value.toString().length));
-					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
-						const separator = isMatch ? ":" : "-";
-						if (useHashLines) {
-							const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
-							return `${ref}${separator}${line}`;
-						}
-						const padded = lineNumber.toString().padStart(lineWidth, " ");
-						return `${padded}${separator}${line}`;
-					};
+					const formatLine = (lineNumber: number, line: string, isMatch: boolean): string =>
+						formatMatchLine(lineNumber, line, isMatch, { useHashLines, lineWidth });
 					if (match.contextBefore) {
 						for (const ctx of match.contextBefore) {
 							outputLines.push(formatLine(ctx.lineNumber, ctx.line, false));

package/src/tools/jtd-to-json-schema.ts

@@ -197,3 +197,19 @@ function normalizeMixedSchemaNode(schema: unknown): unknown {
 export function jtdToJsonSchema(schema: unknown): unknown {
 	return normalizeMixedSchemaNode(schema);
 }
+
+/**
+ * Normalize a schema input that may be a JSON string, object, or null/undefined.
+ * Returns { normalized } on success, or { error } if JSON parsing fails.
+ */
+export function normalizeSchema(schema: unknown): { normalized?: unknown; error?: string } {
+	if (schema === undefined || schema === null) return {};
+	if (typeof schema === "string") {
+		try {
+			return { normalized: JSON.parse(schema) };
+		} catch (err) {
+			return { error: err instanceof Error ? err.message : String(err) };
+		}
+	}
+	return { normalized: schema };
+}

package/src/tools/match-line-format.ts

@@ -0,0 +1,20 @@
+import { computeLineHash } from "../edit/line-hash";
+
+/**
+ * Format a single line of match output for grep/ast-grep style results.
+ * Uses hashline refs when hashlines are enabled, otherwise pads the number.
+ */
+export function formatMatchLine(
+	lineNumber: number,
+	line: string,
+	isMatch: boolean,
+	options: { useHashLines: boolean; lineWidth: number },
+): string {
+	const separator = isMatch ? ":" : "-";
+	if (options.useHashLines) {
+		const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
+		return `${ref}${separator}${line}`;
+	}
+	const padded = lineNumber.toString().padStart(options.lineWidth, " ");
+	return `${padded}${separator}${line}`;
+}

package/src/tools/path-utils.ts

@@ -74,7 +74,7 @@ function normalizeAtPrefix(filePath: string): string {
 		withoutAt.startsWith("artifact://") ||
 		withoutAt.startsWith("skill://") ||
 		withoutAt.startsWith("rule://") ||
-		withoutAt.startsWith("local://") ||
+		withoutAt.startsWith("local:") ||
 		withoutAt.startsWith("mcp://")
 	) {
 		return withoutAt;
@@ -110,6 +110,29 @@ export function expandPath(filePath: string): string {
 	return expandTilde(normalized);
 }
 
+function assertNotInternalUrl(expanded: string, original: string): void {
+	for (const prefix of TOP_LEVEL_INTERNAL_URL_PREFIXES) {
+		if (expanded.startsWith(prefix)) {
+			throw new Error(
+				`Path "${original}" uses internal scheme "${prefix}" and must be resolved through the proper protocol handler, not as a filesystem path.`,
+			);
+		}
+	}
+}
+
+export function normalizeLocalScheme(filePath: string): string {
+	return filePath.replace(/^(local:)\/(?!\/)/, "$1//");
+}
+
+export function isInternalUrlPath(filePath: string): boolean {
+	const normalized = normalizeLocalScheme(filePath);
+	const expandedAndNormalized = normalizeLocalScheme(expandPath(normalized));
+	for (const prefix of TOP_LEVEL_INTERNAL_URL_PREFIXES) {
+		if (expandedAndNormalized.startsWith(prefix)) return true;
+	}
+	return false;
+}
+
 /**
  * Resolve a path relative to the given cwd.
  * Handles ~ expansion and absolute paths.
@@ -119,7 +142,12 @@ export function expandPath(filePath: string): string {
  * filesystem root is almost never what they intended.
  */
 export function resolveToCwd(filePath: string, cwd: string): string {
-	const expanded = expandPath(filePath);
+	const normalized = normalizeLocalScheme(filePath);
+	const expanded = expandPath(normalized);
+	const expandedAndNormalized = normalizeLocalScheme(expanded);
+
+	assertNotInternalUrl(expandedAndNormalized, normalized);
+
 	if (/^\/+$/.test(expanded)) {
 		return cwd;
 	}

package/src/tools/plan-mode-guard.ts

@@ -1,19 +1,20 @@
 import { resolveLocalUrlToPath } from "../internal-urls";
 import type { ToolSession } from ".";
-import { resolveToCwd } from "./path-utils";
+import { normalizeLocalScheme, resolveToCwd } from "./path-utils";
 import { ToolError } from "./tool-errors";
 
-const LOCAL_URL_PREFIX = "local://";
+const LOCAL_SCHEME_PREFIX = "local:";
 
 export function resolvePlanPath(session: ToolSession, targetPath: string): string {
-	if (targetPath.startsWith(LOCAL_URL_PREFIX)) {
-		return resolveLocalUrlToPath(targetPath, {
+	const normalized = normalizeLocalScheme(targetPath);
+	if (normalized.startsWith(LOCAL_SCHEME_PREFIX)) {
+		return resolveLocalUrlToPath(normalized, {
 			getArtifactsDir: session.getArtifactsDir,
 			getSessionId: session.getSessionId,
 		});
 	}
 
-	return resolveToCwd(targetPath, session.cwd);
+	return resolveToCwd(normalized, session.cwd);
 }
 
 export function enforcePlanModeWrite(

package/src/tools/python.ts

@@ -52,7 +52,7 @@ export const pythonSchema = Type.Object({
 		}),
 		{ description: "Cells to execute sequentially in persistent kernel" },
 	),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 30)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 30 })),
 	cwd: Type.Optional(Type.String({ description: "Working directory (default: cwd)" })),
 	reset: Type.Optional(Type.Boolean({ description: "Restart kernel before execution" })),
 });

package/src/tools/read.ts

@@ -371,7 +371,7 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 const readSchema = Type.Object({
 	path: Type.String({ description: "Path or URL to read" }),
 	sel: Type.Optional(Type.String({ description: "Selector: chunk path, L10-L50, or raw" })),
-	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 20)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 20 })),
 });
 
 export type ReadToolInput = Static<typeof readSchema>;

package/src/tools/render-utils.ts

@@ -4,8 +4,10 @@
  * Provides consistent formatting, truncation, and display patterns across all
  * tool renderers to ensure a unified TUI experience.
  */
+
 import * as os from "node:os";
 import * as path from "node:path";
+import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Ellipsis } from "@oh-my-pi/pi-natives";
 import { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { pluralize } from "@oh-my-pi/pi-utils";
@@ -210,6 +212,10 @@ interface ParsedDiagnostic {
 	code?: string;
 }
 
+function sanitizeDiagnosticDisplayText(text: string): string {
+	return replaceTabs(text);
+}
+
 function getSeverityRank(severity: ParsedDiagnostic["severity"]): number {
 	switch (severity) {
 		case "error":
@@ -227,13 +233,13 @@ function parseDiagnosticMessage(msg: string): ParsedDiagnostic | null {
 	const match = msg.match(/^(.+?):(\d+):(\d+)\s+\[(\w+)\]\s+(?:\[([^\]]+)\]\s+)?(.+?)(?:\s+\(([^)]+)\))?$/);
 	if (!match) return null;
 	return {
-		filePath: match[1],
+		filePath: sanitizeDiagnosticDisplayText(match[1]),
 		line: parseInt(match[2], 10),
 		col: parseInt(match[3], 10),
 		severity: match[4] as ParsedDiagnostic["severity"],
-		source: match[5],
-		message: match[6],
-		code: match[7],
+		source: match[5] ? sanitizeDiagnosticDisplayText(match[5]) : undefined,
+		message: sanitizeDiagnosticDisplayText(match[6]),
+		code: match[7] ? sanitizeDiagnosticDisplayText(match[7]) : undefined,
 	};
 }
 
@@ -255,7 +261,7 @@ export function formatDiagnostics(
 			existing.push(parsed);
 			byFile.set(parsed.filePath, existing);
 		} else {
-			unparsed.push(msg);
+			unparsed.push(sanitizeDiagnosticDisplayText(msg));
 		}
 	}
 
@@ -272,7 +278,8 @@ export function formatDiagnostics(
 	const headerIcon = diag.errored
 		? theme.styledSymbol("status.error", "error")
 		: theme.styledSymbol("status.warning", "warning");
-	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${diag.summary})`)}`;
+	const summary = sanitizeDiagnosticDisplayText(diag.summary);
+	let output = `\n\n${headerIcon} ${theme.fg("toolTitle", "Diagnostics")} ${theme.fg("dim", `(${summary})`)}`;
 
 	const maxDiags = expanded ? diag.messages.length : 5;
 	let diagsShown = 0;
@@ -616,3 +623,28 @@ export function formatParseErrors(errors: string[]): string[] {
 			: "Parse issues:";
 	return [header, ...capped.map(err => `- ${err}`)];
 }
+
+// =============================================================================
+// LSP Batching
+// =============================================================================
+
+const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
+
+export interface LspBatchRequest {
+	id: string;
+	flush: boolean;
+}
+
+export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined {
+	if (!toolCall) {
+		return undefined;
+	}
+	const hasOtherWrites = toolCall.toolCalls.some(
+		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
+	);
+	if (!hasOtherWrites) {
+		return undefined;
+	}
+	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some(call => LSP_BATCH_TOOLS.has(call.name));
+	return { id: toolCall.batchId, flush: !hasLaterWrites };
+}

package/src/tools/renderers.ts

@@ -51,6 +51,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	python: pythonToolRenderer as ToolRenderer,
 	calc: calculatorToolRenderer as ToolRenderer,
 	edit: editToolRenderer as ToolRenderer,
+	apply_patch: editToolRenderer as ToolRenderer,
 	find: findToolRenderer as ToolRenderer,
 	grep: grepToolRenderer as ToolRenderer,
 	lsp: lspToolRenderer as ToolRenderer,

package/src/tools/ssh.ts

@@ -9,7 +9,7 @@ import { loadCapability } from "../discovery";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import sshDescriptionBase from "../prompts/tools/ssh.md" with { type: "text" };
-import { DEFAULT_MAX_BYTES, TailBuffer } from "../session/streaming-output";
+import { DEFAULT_MAX_BYTES, streamTailUpdates, TailBuffer } from "../session/streaming-output";
 import type { SSHHostInfo } from "../ssh/connection-manager";
 import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
 import { executeSSH } from "../ssh/ssh-executor";
@@ -25,7 +25,7 @@ const sshSchema = Type.Object({
 	host: Type.String({ description: "Host name from managed SSH config or discovered ssh.json files" }),
 	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 (default: 60)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds", default: 60 })),
 });
 
 export interface SSHToolDetails {
@@ -168,15 +168,7 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 			compatEnabled: hostInfo.compatEnabled,
 			artifactPath,
 			artifactId,
-			onChunk: chunk => {
-				tailBuffer.append(chunk);
-				if (onUpdate) {
-					onUpdate({
-						content: [{ type: "text", text: tailBuffer.text() }],
-						details: {},
-					});
-				}
-			},
+			onChunk: streamTailUpdates(tailBuffer, onUpdate),
 		});
 
 		if (result.cancelled) {

package/src/tools/submit-result.ts

@@ -10,7 +10,7 @@ import { Type } from "@sinclair/typebox";
 import Ajv, { type ErrorObject, type ValidateFunction } from "ajv";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
 import type { ToolSession } from ".";
-import { jtdToJsonSchema } from "./jtd-to-json-schema";
+import { jtdToJsonSchema, normalizeSchema } from "./jtd-to-json-schema";
 
 export interface SubmitResultDetails {
 	data: unknown;
@@ -20,18 +20,6 @@ export interface SubmitResultDetails {
 
 const ajv = new Ajv({ allErrors: true, strict: false, logger: false });
 
-function normalizeSchema(schema: unknown): { normalized?: unknown; error?: string } {
-	if (schema === undefined || schema === null) return {};
-	if (typeof schema === "string") {
-		try {
-			return { normalized: JSON.parse(schema) };
-		} catch (err) {
-			return { error: err instanceof Error ? err.message : String(err) };
-		}
-	}
-	return { normalized: schema };
-}
-
 function formatSchema(schema: unknown): string {
 	if (schema === undefined) return "No schema provided.";
 	if (typeof schema === "string") return schema;