@oh-my-pi/pi-tui 18.2.3 → 18.2.5

package/src/tools/subprocess.ts

@@ -0,0 +1,39 @@
+import type { Component } from "../tui";
+import type { Theme } from "../theme/theme";
+import { Text } from "../components/text";
+import { renderNestedTaskResults, type TaskToolDetails } from "./task";
+
+/** Display callbacks for structured data extracted from a child agent tool. */
+export interface SubprocessToolRenderer<TData = unknown> {
+	/**
+	 * Render a single data item inline during streaming progress.
+	 * Called for each tool execution end event.
+	 */
+	renderInline?: (data: TData, theme: Theme) => Component;
+
+	/**
+	 * Render accumulated data in the final result view.
+	 * Called once with all accumulated data for this tool.
+	 */
+	renderFinal?: (allData: TData[], theme: Theme, expanded: boolean) => Component;
+}
+const renderers = new Map<string, SubprocessToolRenderer>();
+
+/** Renders nested task results extracted from child agents. */
+export const taskSubprocessRenderer = {
+	renderFinal(allData: TaskToolDetails[], theme: Theme, expanded: boolean): Component {
+		return new Text(renderNestedTaskResults(allData, expanded, theme).join("\n"), 0, 0);
+	},
+} satisfies SubprocessToolRenderer<TaskToolDetails>;
+
+registerSubprocessToolRenderer("task", taskSubprocessRenderer);
+
+/** Registers the display callbacks for a subprocess tool without its execution handler. */
+export function registerSubprocessToolRenderer<T>(toolName: string, renderer: SubprocessToolRenderer<T>): void {
+	renderers.set(toolName, renderer as SubprocessToolRenderer);
+}
+
+/** Looks up the display callbacks for a subprocess tool. */
+export function getSubprocessToolRenderer(toolName: string): SubprocessToolRenderer | undefined {
+	return renderers.get(toolName);
+}

package/src/tools/task-repair-args.ts

@@ -0,0 +1,118 @@
+/**
+ * Repair double-encoded JSON string arguments for the task tool.
+ *
+ * Models occasionally JSON-escape a string value twice when emitting a
+ * `task` tool call, so a `task` field that should read
+ *
+ *     # Role
+ *     You are a judge … "describe this" … return —
+ *
+ * arrives — after the one JSON decode the provider already applied — as the
+ * literal text
+ *
+ *     # Role\nYou are a judge … \"describe this\" … return \u2014
+ *
+ * i.e. every newline, quote, and unicode character is still backslash-escaped.
+ * The subagent then receives that garbled prompt, and the call preview renders
+ * one long blob with visible `\n` / `\"` / `\uXXXX`.
+ *
+ * The *whole-arguments* form of this quirk (the entire `arguments` blob is a
+ * JSON string) is already auto-corrected by the validator's JSON-string
+ * coercion. This module handles the *per-field* form, where the object parses
+ * fine but an individual string value is double-encoded — the validator never
+ * fires there because a double-encoded string is still a structurally valid
+ * string.
+ *
+ * This is deliberately scoped to the task tool's natural-language fields
+ * (`task`, shared `context`); identifier fields (`name`, `agent`)
+ * are never repaired. It is NOT applied to code-bearing
+ * tools (write/edit/bash/search), where a backslash or quote is load-bearing
+ * and a false-positive unescape would silently corrupt a file or command.
+ */
+import type { TaskItem, TaskParams } from "./task";
+
+/** A backslash that escapes a structural char — `\"`, `\\`, `\/`, or `\uXXXX`. */
+const STRUCTURAL_ESCAPE = /\\(?:["\\/]|u[0-9a-fA-F]{4})/;
+
+/**
+ * Whether `value` carries the signature of whole-string double-encoding rather
+ * than an incidental escape mention. A lone `\n`/`\t` in an instruction (e.g.
+ * "split lines on \n") is far more likely a literal mention than a
+ * double-encoded document, so it is left alone; a structural escape (`\"`,
+ * `\\`, `\uXXXX`) or two-plus escape sequences indicates a re-escaped payload.
+ */
+function hasDoubleEncodeSignature(value: string): boolean {
+	if (STRUCTURAL_ESCAPE.test(value)) return true;
+	let count = 0;
+	for (let i = 0; i < value.length; i++) {
+		if (value.charCodeAt(i) === 0x5c /* \ */) {
+			count += 1;
+			if (count >= 2) return true;
+			i += 1; // skip the escaped char so `\\` counts once
+		}
+	}
+	return false;
+}
+
+/**
+ * Return the once-unescaped string when `value` is uniformly double-encoded
+ * JSON (a well-formed JSON string body that decodes to a different string);
+ * otherwise return `value` unchanged.
+ *
+ * The `JSON.parse(\`"${value}"\`)` round-trip is the safety net: it only
+ * succeeds when *every* backslash begins a valid JSON escape and no bare
+ * double-quote exists — exactly the signature of double-encoding. Genuine
+ * prose with a Windows path (`C:\Users`), a regex (`\d+`), an embedded quote,
+ * or a real (already-decoded) newline makes the parse throw, so the value is
+ * returned untouched.
+ */
+export function repairDoubleEncodedJsonString(value: string): string {
+	// Fast path: no backslash → nothing was escaped → the parse can never differ.
+	if (!value.includes("\\")) return value;
+	if (!hasDoubleEncodeSignature(value)) return value;
+	let decoded: unknown;
+	try {
+		decoded = JSON.parse(`"${value}"`);
+	} catch {
+		return value;
+	}
+	return typeof decoded === "string" && decoded !== value ? decoded : value;
+}
+
+/** Repair a single (possibly partial) task item's prose field (`task`). */
+function repairTaskItem(item: TaskItem): TaskItem {
+	if (item === null || typeof item !== "object") return item;
+	const task = typeof item.task === "string" ? repairDoubleEncodedJsonString(item.task) : item.task;
+	if (task === item.task) return item;
+	return { ...item, task };
+}
+
+/**
+ * Repair double-encoded prose in task-tool params (flat `task`, shared
+ * `context`, and each batch task item's `task`). Returns the same reference
+ * when nothing changed so callers can cheaply skip work. Defensive against
+ * partially-streamed args (missing/undefined fields, partial task arrays) so
+ * it is safe on the render path as well as on execution.
+ */
+export function repairTaskParams(params: TaskParams): TaskParams {
+	if (params === null || typeof params !== "object") return params;
+
+	const task = typeof params.task === "string" ? repairDoubleEncodedJsonString(params.task) : params.task;
+	const context = typeof params.context === "string" ? repairDoubleEncodedJsonString(params.context) : params.context;
+
+	let tasks = params.tasks;
+	if (Array.isArray(params.tasks)) {
+		let changed = false;
+		const repaired = params.tasks.map(item => {
+			const next = repairTaskItem(item);
+			if (next !== item) changed = true;
+			return next;
+		});
+		if (changed) tasks = repaired;
+	}
+
+	if (task === params.task && context === params.context && tasks === params.tasks) {
+		return params;
+	}
+	return { ...params, task, context, tasks };
+}

package/src/tools/task-yield-assembly.ts

@@ -0,0 +1,147 @@
+import type { YieldItem } from "./task";
+/** Outcome of folding a run's yield calls into one payload, with provenance flags. */
+interface AssembledYieldResult {
+	data: unknown;
+	schemaOverridden: boolean;
+	rawText: boolean;
+	missingData: boolean;
+}
+
+function isIncrementalYieldType(type: YieldItem["type"]): type is string[] {
+	return Array.isArray(type) && type.length > 0;
+}
+
+function getYieldLabels(type: YieldItem["type"]): string[] {
+	if (typeof type === "string") {
+		const label = type.trim();
+		return label ? [label] : [];
+	}
+	if (!Array.isArray(type)) return [];
+	const labels: string[] = [];
+	for (const value of type) {
+		if (typeof value !== "string") continue;
+		const label = value.trim();
+		if (label) labels.push(label);
+	}
+	return labels;
+}
+
+function resolveYieldPayload(
+	item: YieldItem,
+	lastAssistantText: string | undefined,
+	labels: string[],
+): { value: unknown; fromLastAssistantText: boolean; missingData: boolean } {
+	const hasData = item.data !== undefined;
+	const shouldUseLastTurn = item.useLastTurn === true || (labels.length > 0 && !hasData);
+	if (shouldUseLastTurn && lastAssistantText !== undefined) {
+		return {
+			value: lastAssistantText,
+			fromLastAssistantText: true,
+			missingData: lastAssistantText.length === 0,
+		};
+	}
+	return {
+		value: item.data,
+		fromLastAssistantText: false,
+		missingData: item.data === undefined || item.data === null,
+	};
+}
+
+function appendYieldSection(
+	sections: Record<string, unknown>,
+	sectionCounts: Map<string, number>,
+	label: string,
+	value: unknown,
+	forceArray: boolean,
+): void {
+	const count = sectionCounts.get(label) ?? 0;
+	const existing = sections[label];
+	if (count === 0) {
+		sections[label] = forceArray ? [value] : value;
+	} else if (Array.isArray(existing)) {
+		existing.push(value);
+	} else {
+		sections[label] = [existing, value];
+	}
+	sectionCounts.set(label, count + 1);
+}
+
+/**
+ * Assemble typed yield calls into the final payload consumed by schema validation.
+ *
+ * A non-empty array `type` contributes an incremental section and never decides
+ * termination by itself. A string `type` with omitted `data` makes the last
+ * assistant turn the raw terminal result. Other string-typed yields contribute
+ * the terminal labelled section. Untyped terminal yields keep the historical
+ * "last yield wins" behavior unless no terminal yield exists, in which case
+ * accumulated typed sections finalize on idle.
+ */
+export function assembleYieldResult(
+	yieldItems: YieldItem[],
+	lastAssistantText?: string,
+	arrayLabels?: ReadonlySet<string>,
+): AssembledYieldResult | undefined {
+	if (yieldItems.length === 0) return undefined;
+
+	// Terminal = the last non-incremental yield (untyped, or string-typed like
+	// `type: "result"`). Array-typed yields are incremental sections and never
+	// terminate on their own.
+	let terminalItem: YieldItem | undefined;
+	for (let index = yieldItems.length - 1; index >= 0; index--) {
+		const item = yieldItems[index];
+		if (item && !isIncrementalYieldType(item.type)) {
+			terminalItem = item;
+			break;
+		}
+	}
+
+	// Sections come ONLY from incremental (array-typed) yields. A string `type`
+	// is a terminal marker, never a section label: folding its data under the
+	// label is what nested a finalize payload (`type: "result"`, `data: {…}`) one
+	// level deep and made output-schema validation report every field missing.
+	const sections: Record<string, unknown> = {};
+	const sectionCounts = new Map<string, number>();
+	let schemaOverridden = false;
+	let missingData = false;
+	let hasSections = false;
+	for (const item of yieldItems) {
+		if (item.status === "aborted") continue;
+		if (!isIncrementalYieldType(item.type)) continue;
+		schemaOverridden ||= item.schemaOverridden === true;
+		const labels = getYieldLabels(item.type);
+		const resolved = resolveYieldPayload(item, lastAssistantText, labels);
+		missingData ||= resolved.missingData;
+		for (const label of labels) {
+			appendYieldSection(sections, sectionCounts, label, resolved.value, arrayLabels?.has(label) ?? false);
+			hasSections = true;
+		}
+	}
+
+	// An explicit terminal payload wins: an untyped final result or a
+	// `type: "result"` finalize that carries `data` is the complete result, used
+	// verbatim — never wrapped in a section.
+	if (terminalItem && terminalItem.data !== undefined) {
+		const resolved = resolveYieldPayload(terminalItem, lastAssistantText, []);
+		return {
+			data: resolved.value,
+			schemaOverridden: terminalItem.schemaOverridden === true,
+			rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+			missingData: resolved.missingData,
+		};
+	}
+
+	// A data-less terminal finalize keeps accumulated sections; only when none
+	// exist does the last assistant turn become the raw result.
+	if (hasSections) {
+		return { data: sections, schemaOverridden, rawText: false, missingData };
+	}
+
+	if (!terminalItem) return undefined;
+	const resolved = resolveYieldPayload(terminalItem, lastAssistantText, getYieldLabels(terminalItem.type));
+	return {
+		data: resolved.value,
+		schemaOverridden: terminalItem.schemaOverridden === true,
+		rawText: resolved.fromLastAssistantText && typeof resolved.value === "string",
+		missingData: resolved.missingData,
+	};
+}