@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/src/tools/fetch.ts

@@ -10,6 +10,7 @@ import type { Settings } from "../config/settings";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme, theme } from "../modes/theme/theme";
 import type { ToolSession } from "../sdk";
+import type { AgentStorage } from "../session/agent-storage";
 import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
@@ -542,7 +543,8 @@ async function renderHtmlToText(
 	html: string,
 	timeout: number,
 	settings: Settings,
-	userSignal?: AbortSignal,
+	userSignal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<{ content: string; ok: boolean; method: string }> {
 	const signal = ptree.combineSignals(userSignal, timeout * 1000);
 	const execOptions = {
@@ -554,14 +556,18 @@ async function renderHtmlToText(
 	};
 
 	// Try Parallel extract first when credentials are configured
-	if (settings.get("providers.parallelFetch") && (await findParallelApiKey())) {
+	if (settings.get("providers.parallelFetch") && findParallelApiKey(storage)) {
 		try {
-			const parallelResult = await extractWithParallel([url], {
-				objective: "Extract the main content",
-				excerpts: true,
-				fullContent: false,
-				signal,
-			});
+			const parallelResult = await extractWithParallel(
+				[url],
+				{
+					objective: "Extract the main content",
+					excerpts: true,
+					fullContent: false,
+					signal,
+				},
+				storage,
+			);
 			const firstDocument = parallelResult.results[0];
 			if (firstDocument) {
 				const content = getParallelExtractContent(firstDocument);
@@ -682,13 +688,14 @@ type FetchRenderResult = RenderResult & {
 async function handleSpecialUrls(
 	url: string,
 	timeout: number,
-	signal?: AbortSignal,
+	signal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<FetchRenderResult | null> {
 	for (const handler of specialHandlers) {
 		if (signal?.aborted) {
 			throw new ToolAbortError();
 		}
-		const result = await handler(url, timeout, signal);
+		const result = await handler(url, timeout, signal, storage);
 		if (result) return result;
 	}
 	return null;
@@ -706,7 +713,8 @@ async function renderUrl(
 	timeout: number,
 	raw: boolean,
 	settings: Settings,
-	signal?: AbortSignal,
+	signal: AbortSignal | undefined,
+	storage: AgentStorage | null,
 ): Promise<FetchRenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
@@ -733,7 +741,7 @@ async function renderUrl(
 
 	// Step 1: Try special handlers for known sites (unless raw mode)
 	if (!raw) {
-		const specialResult = await handleSpecialUrls(url, timeout, signal);
+		const specialResult = await handleSpecialUrls(url, timeout, signal, storage);
 		if (specialResult) return specialResult;
 	}
 
@@ -1051,7 +1059,7 @@ async function renderUrl(
 		}
 
 		// 5E: Render HTML with lynx or html2text
-		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal);
+		const htmlResult = await renderHtmlToText(finalUrl, rawContent, timeout, settings, signal, storage);
 		if (!htmlResult.ok) {
 			notes.push("html rendering failed (lynx/html2text unavailable)");
 			const output = finalizeOutput(rawContent);
@@ -1233,7 +1241,8 @@ async function buildReadUrlCacheEntry(
 		throw new ToolAbortError();
 	}
 
-	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal);
+	const storage = session.settings.getStorage();
+	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal, storage);
 	const output = buildUrlReadOutput(result, result.content);
 	const artifactId = options?.ensureArtifact ? await persistReadUrlArtifact(session, output) : undefined;
 

package/src/tools/index.ts

@@ -91,7 +91,6 @@ export * from "./search";
 export * from "./search-tool-bm25";
 export * from "./ssh";
 export * from "./todo-write";
-export * from "./vim";
 export * from "./write";
 export * from "./yield";
 
@@ -104,7 +103,6 @@ export type ContextFileEntry = {
 	depth?: number;
 };
 
-export type { DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
 export type {
 	DiscoverableTool,
 	DiscoverableToolSearchIndex,
@@ -140,6 +138,8 @@ export interface ToolSession {
 	requireYieldTool?: boolean;
 	/** Task recursion depth (0 = top-level, 1 = first child, etc.) */
 	taskDepth?: number;
+	/** Get shared eval executor session ID. Subagents inherit this to share JS/Python state. */
+	getEvalSessionId?: () => string | null;
 	/** Get session file */
 	getSessionFile: () => string | null;
 	/** Get eval kernel owner ID for session-scoped retained-kernel cleanup. */
@@ -194,12 +194,6 @@ export interface ToolSession {
 	setTodoPhases?: (phases: TodoPhase[]) => void;
 	/** Whether MCP tool discovery is active for this session. */
 	isMCPDiscoveryEnabled?: () => boolean;
-	/** Get hidden-but-discoverable MCP tools for search_tool_bm25 prompts and fallbacks.
-	 * @deprecated Use getDiscoverableTools with source filter instead. */
-	getDiscoverableMCPTools?: () => import("../mcp/discoverable-tool-metadata").DiscoverableMCPTool[];
-	/** Get the cached discoverable MCP search index for search_tool_bm25 execution.
-	 * @deprecated Use getDiscoverableToolSearchIndex instead. */
-	getDiscoverableMCPSearchIndex?: () => import("../tool-discovery/tool-index").DiscoverableMCPSearchIndex;
 	/** Get MCP tools activated by prior search_tool_bm25 calls. */
 	getSelectedMCPToolNames?: () => string[];
 	/** Merge MCP tool selections into the active session tool set. */

package/src/tools/irc.ts

@@ -25,6 +25,7 @@ import ircDescription from "../prompts/tools/irc.md" with { type: "text" };
 import type { AgentRef, AgentRegistry } from "../registry/agent-registry";
 import type { ToolSession } from ".";
 
+const DEFAULT_IRC_TIMEOUT_MS = 120_000;
 const ircSchema = z.object({
 	op: z.enum(["send", "list"]).describe("irc operation"),
 	to: z.string().optional().describe('recipient agent id or "all"'),
@@ -159,6 +160,7 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 
 		const awaitReply = params.awaitReply ?? !isBroadcast;
 
+		const timeoutMs = normalizeIrcTimeoutMs(this.session.settings.get("irc.timeoutMs"));
 		const delivered: string[] = [];
 		const replies: IrcReply[] = [];
 		const failed: Array<{ id: string; error: string }> = [];
@@ -174,12 +176,18 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 				return;
 			}
 			try {
-				const result = await targetSession.respondAsBackground({
-					from: senderId,
-					message,
-					awaitReply,
+				const result = await runIrcDispatchWithTimeout(
+					timeoutMs,
 					signal,
-				});
+					timeoutSignal =>
+						targetSession.respondAsBackground({
+							from: senderId,
+							message,
+							awaitReply,
+							signal: timeoutSignal,
+						}),
+					target.id,
+				);
 				delivered.push(target.id);
 				if (awaitReply && result.replyText) {
 					replies.push({ from: target.id, text: result.replyText });
@@ -237,3 +245,49 @@ function errorResult(text: string, details: IrcDetails): AgentToolResult<IrcDeta
 		details,
 	};
 }
+
+function normalizeIrcTimeoutMs(value: number): number {
+	if (!Number.isFinite(value) || value === 0) return value === 0 ? 0 : DEFAULT_IRC_TIMEOUT_MS;
+	return Math.max(1, Math.trunc(value));
+}
+
+async function runIrcDispatchWithTimeout<T>(
+	timeoutMs: number,
+	parentSignal: AbortSignal | undefined,
+	run: (signal?: AbortSignal) => Promise<T>,
+	targetId: string,
+): Promise<T> {
+	if (timeoutMs <= 0) {
+		return await run(parentSignal);
+	}
+
+	const controller = new AbortController();
+	const timeoutError = new Error(`IRC timed out waiting for ${targetId} after ${timeoutMs} ms`);
+	let timeout: NodeJS.Timeout | undefined;
+	let parentAbortListener: (() => void) | undefined;
+
+	const timeoutDeferred = Promise.withResolvers<never>();
+	if (parentSignal) {
+		if (parentSignal.aborted) {
+			throw parentSignal.reason instanceof Error ? parentSignal.reason : new Error("IRC aborted");
+		}
+		parentAbortListener = () => {
+			controller.abort(parentSignal.reason);
+			timeoutDeferred.reject(parentSignal.reason instanceof Error ? parentSignal.reason : new Error("IRC aborted"));
+		};
+		parentSignal.addEventListener("abort", parentAbortListener, { once: true });
+	}
+
+	timeout = setTimeout(() => {
+		controller.abort(timeoutError);
+		timeoutDeferred.reject(timeoutError);
+	}, timeoutMs);
+	timeout.unref?.();
+
+	try {
+		return await Promise.race([run(controller.signal), timeoutDeferred.promise]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+		if (parentSignal && parentAbortListener) parentSignal.removeEventListener("abort", parentAbortListener);
+	}
+}

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

@@ -1,12 +1,10 @@
-import { computeLineHash } from "../hashline/hash";
-
 /**
  * Format a single line of match output for grep/ast-grep style results.
  *
- * The anchor/content separator is always `|`. Matched lines are prefixed
- * with `*`; context lines are prefixed with a single space so anchors
- * align in column. In hashline mode the anchor is `LINE+ID` (no `#`); in
- * plain mode it is just the line number. Line numbers are never padded.
+ * Matched lines are prefixed with `*`; context lines are prefixed with a single
+ * space so line numbers align in column. In hashline mode the line uses the
+ * editable `LINE:content` shape under a file-hash header; in plain mode it keeps
+ * the legacy `LINE|content` display-only shape. Line numbers are never padded.
  */
 export function formatMatchLine(
 	lineNumber: number,
@@ -16,7 +14,7 @@ export function formatMatchLine(
 ): string {
 	const marker = isMatch ? "*" : " ";
 	if (options.useHashLines) {
-		return `${marker}${lineNumber}${computeLineHash(lineNumber, line)}|${line}`;
+		return `${marker}${lineNumber}:${line}`;
 	}
 	return `${marker}${lineNumber}|${line}`;
 }

package/src/tools/output-schema-validator.ts

@@ -0,0 +1,132 @@
+/**
+ * Shared output-schema validation for subagent yield + executor finalization.
+ *
+ * Both the in-process `yield` tool (subagent side) and the executor's post-mortem
+ * finalize path (parent side) need to validate yield payloads against the agent's
+ * declared output schema. This module is the single source of truth for that
+ * pipeline — keeping the two callsites in lockstep so a schema accepted in-tool
+ * cannot be rejected post-mortem (or vice versa).
+ */
+import {
+	isValidJsonSchema,
+	type JsonSchemaValidationIssue,
+	type JsonSchemaValidationResult,
+	validateJsonSchemaValue,
+} from "@oh-my-pi/pi-ai/utils/schema";
+import { jtdToJsonSchema, normalizeSchema } from "./jtd-to-json-schema";
+
+/** A validator bound to a specific output schema. */
+export interface OutputValidator {
+	/** Run JSON Schema validation; returns the raw `success`/`issues` shape so callers may inspect every failure. */
+	validate(value: unknown): JsonSchemaValidationResult;
+	/** Top-level required property names. Empty if the schema has no `required` array at root. */
+	readonly requiredFields: readonly string[];
+}
+
+export interface BuildOutputValidatorResult {
+	/** Present when the schema produced a usable validator (i.e. constraining schemas). Absent for missing/unconstrained schemas. */
+	validator?: OutputValidator;
+	/** Raw JSON Schema produced by `jtdToJsonSchema`. Available alongside the validator so callers can derive related artifacts (strict-mode probe, dereference, hint text). */
+	jsonSchema?: Record<string, unknown>;
+	/**
+	 * Normalized schema (post-`normalizeSchema`). Surfaced so callers can distinguish
+	 * "no schema provided" (`undefined`) from "intentionally unconstrained" (`true`)
+	 * when both produce no validator.
+	 */
+	normalized?: unknown;
+	/** Set when the schema cannot be used. Callers should treat this as a "no validation" case (loose acceptance) and surface the message in diagnostics. */
+	error?: string;
+}
+
+/**
+ * Build the canonical validator for a JTD-or-JSON-Schema output declaration.
+ *
+ * Returns:
+ * - `{ validator, jsonSchema, normalized }` for constraining schemas — both callers use this path.
+ * - `{ normalized: true }` for an intentionally unconstrained schema (the JSON Schema literal `true`).
+ *   No validator, but distinguishable from "no schema provided".
+ * - `{}` for an absent schema (`undefined`).
+ * - `{ error, normalized? }` when the schema cannot be honored (invalid syntax, `false`, malformed JTD).
+ */
+export function buildOutputValidator(schema: unknown): BuildOutputValidatorResult {
+	const { normalized, error: normalizeError } = normalizeSchema(schema);
+	if (normalizeError) return { error: normalizeError, normalized };
+	if (normalized === undefined) return {};
+	if (normalized === false) return { error: "boolean false schema rejects all outputs", normalized };
+	if (normalized === true) return { normalized };
+
+	const jsonSchema = jtdToJsonSchema(normalized);
+	if (jsonSchema === undefined) return { normalized };
+	if (jsonSchema === false) return { error: "boolean false schema rejects all outputs", normalized };
+	if (jsonSchema === true) return { normalized };
+	if (typeof jsonSchema !== "object" || Array.isArray(jsonSchema)) {
+		return { error: "invalid JSON schema", normalized };
+	}
+	if (!isValidJsonSchema(jsonSchema)) return { error: "invalid JSON schema", normalized };
+
+	const jsonSchemaRecord = jsonSchema as Record<string, unknown>;
+	const required = extractRequiredFields(jsonSchemaRecord);
+	return {
+		normalized,
+		jsonSchema: jsonSchemaRecord,
+		validator: {
+			requiredFields: required,
+			validate: value => validateJsonSchemaValue(jsonSchemaRecord, value),
+		},
+	};
+}
+
+/** Produce the executor's headline+missing-required summary from a failed validation. */
+export function summarizeValidationFailure(
+	result: JsonSchemaValidationResult,
+	value: unknown,
+	requiredFields: readonly string[],
+): { message: string; missingRequired: string[] } {
+	if (result.success) return { message: "", missingRequired: [] };
+	const missing = computeMissingRequired(requiredFields, value);
+	const message = formatValidationIssueHeadline(result.issues[0]) ?? "schema validation failed";
+	return { message, missingRequired: missing };
+}
+
+export function extractRequiredFields(jsonSchema: unknown): string[] {
+	if (!jsonSchema || typeof jsonSchema !== "object") return [];
+	const required = (jsonSchema as { required?: unknown }).required;
+	return Array.isArray(required) ? required.filter((k): k is string => typeof k === "string") : [];
+}
+
+export function computeMissingRequired(required: readonly string[], value: unknown): string[] {
+	if (required.length === 0) return [];
+	if (value === null || value === undefined) return [...required];
+	if (typeof value !== "object" || Array.isArray(value)) return [];
+	const record = value as Record<string, unknown>;
+	return required.filter(key => !(key in record) || record[key] === undefined);
+}
+
+/**
+ * Format a single validation issue as `path.with.dots: message`.
+ *
+ * Used by the executor's post-mortem `schema_violation` headline — one line, dot-separated path,
+ * since the executor's error format already lists missing-required fields separately.
+ */
+export function formatValidationIssueHeadline(issue: JsonSchemaValidationIssue | undefined): string | undefined {
+	if (!issue) return undefined;
+	const path = issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)";
+	return `${path}: ${issue.message}`;
+}
+
+/**
+ * Format every validation issue as `path/with/slashes: message; ...`.
+ *
+ * Used by the yield tool's model-facing retry feedback — the model gets every problem at once so it
+ * can fix the entire output in one retry instead of iterating issue-by-issue. The slash separator
+ * mirrors JSON Pointer convention and disambiguates against fields whose names contain dots.
+ */
+export function formatAllValidationIssues(issues: ReadonlyArray<JsonSchemaValidationIssue> | undefined): string {
+	if (!issues || issues.length === 0) return "Unknown schema validation error.";
+	return issues
+		.map(issue => {
+			const path = issue.path.length === 0 ? "" : `${issue.path.map(seg => String(seg)).join("/")}: `;
+			return `${path}${issue.message}`;
+		})
+		.join("; ");
+}