@oh-my-pi/pi-coding-agent 16.1.15 → 16.1.16

package/src/tools/todo.ts

@@ -52,21 +52,18 @@ const InitListEntry = type({
 	items: type("string").describe("task content").array().atLeastLength(1).describe("tasks for this phase"),
 });
 
-const TodoOpEntry = type({
+const todoSchema = type({
 	op: TodoOp,
 	"list?": InitListEntry.array().describe("phased task list (init)"),
 	"task?": type("string").describe("task content"),
 	"phase?": type("string").describe("phase name"),
 	"items?": type("string").describe("task content").array().atLeastLength(1).describe("tasks to append"),
-});
-
-const todoSchema = type({
-	ops: TodoOpEntry.array().atLeastLength(1).describe("ordered todo operations"),
-}).describe("apply ordered todo operations");
+}).describe("apply a single todo operation");
 
 type TodoParams = TodoSchema;
 type TodoSchema = typeof todoSchema.infer;
-type TodoOpEntryValue = TodoParams["ops"][number];
+/** A single todo op entry (the params object itself). */
+type TodoOpEntryValue = TodoParams;
 
 // =============================================================================
 // State helpers
@@ -402,10 +399,7 @@ function applyEntry(phases: TodoPhase[], entry: TodoOpEntryValue, errors: string
 
 function applyParams(phases: TodoPhase[], params: TodoParams): { phases: TodoPhase[]; errors: string[] } {
 	const errors: string[] = [];
-	let next = phases;
-	for (const entry of params.ops) {
-		next = applyEntry(next, entry, errors);
-	}
+	const next = applyEntry(phases, params, errors);
 	normalizeInProgressTask(next);
 	return { phases: next, errors };
 }
@@ -413,9 +407,15 @@ function applyParams(phases: TodoPhase[], params: TodoParams): { phases: TodoPha
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
 export function applyOpsToPhases(
 	currentPhases: TodoPhase[],
-	ops: TodoParams["ops"],
+	ops: TodoParams[],
 ): { phases: TodoPhase[]; errors: string[] } {
-	return applyParams(clonePhases(currentPhases), { ops });
+	const errors: string[] = [];
+	let next = clonePhases(currentPhases);
+	for (const op of ops) {
+		next = applyEntry(next, op, errors);
+	}
+	normalizeInProgressTask(next);
+	return { phases: next, errors };
 }
 
 // =============================================================================
@@ -572,64 +572,44 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 		{
 			caption: "Initial setup (multi-phase)",
 			call: {
-				ops: [
-					{
-						op: "init",
-						list: [
-							{ phase: "Foundation", items: ["Scaffold crate", "Wire workspace"] },
-							{ phase: "Auth", items: ["Port credential store", "Wire OAuth providers"] },
-							{ phase: "Verification", items: ["Run cargo test"] },
-						],
-					},
+				op: "init",
+				list: [
+					{ phase: "Foundation", items: ["Scaffold crate", "Wire workspace"] },
+					{ phase: "Auth", items: ["Port credential store", "Wire OAuth providers"] },
+					{ phase: "Verification", items: ["Run cargo test"] },
 				],
 			},
 		},
 		{
 			caption: "View current state (read-only)",
-			call: {
-				ops: [{ op: "view" }],
-			},
+			call: { op: "view" },
 		},
 		{
 			caption: "Initial setup (single phase)",
 			call: {
-				ops: [
-					{
-						op: "init",
-						list: [{ phase: "Implementation", items: ["Apply fix", "Run tests"] }],
-					},
-				],
+				op: "init",
+				list: [{ phase: "Implementation", items: ["Apply fix", "Run tests"] }],
 			},
 		},
 		{
 			caption: "Complete one task",
-			call: {
-				ops: [{ op: "done", task: "Wire workspace" }],
-			},
+			call: { op: "done", task: "Wire workspace" },
 		},
 		{
 			caption: "Complete a whole phase",
-			call: {
-				ops: [{ op: "done", phase: "Auth" }],
-			},
+			call: { op: "done", phase: "Auth" },
 		},
 		{
 			caption: "Remove all tasks",
-			call: {
-				ops: [{ op: "rm" }],
-			},
+			call: { op: "rm" },
 		},
 		{
 			caption: "Drop one task",
-			call: {
-				ops: [{ op: "drop", task: "Run cargo test" }],
-			},
+			call: { op: "drop", task: "Run cargo test" },
 		},
 		{
 			caption: "Append tasks to a phase",
-			call: {
-				ops: [{ op: "append", phase: "Auth", items: ["Handle retries", "Run tests"] }],
-			},
+			call: { op: "append", phase: "Auth", items: ["Handle retries", "Run tests"] },
 		},
 	];
 	readonly loadMode = "discoverable";
@@ -646,7 +626,7 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 	): Promise<AgentToolResult<TodoToolDetails>> {
 		const previousPhases = clonePhases(this.session.getTodoPhases?.() ?? []);
 		// Pure-view calls are reads: no normalization, no state write.
-		const readOnly = params.ops.every(entry => entry.op === "view");
+		const readOnly = params.op === "view";
 		const { phases: updated, errors } = readOnly
 			? { phases: previousPhases, errors: [] as string[] }
 			: applyParams(clonePhases(previousPhases), params);
@@ -673,15 +653,32 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 // TUI Renderer
 // =============================================================================
 
-type TodoRenderArgs = {
-	ops?: Array<{
-		op?: string;
-		task?: string;
-		phase?: string;
-		items?: string[];
-	}>;
+type TodoRenderOp = {
+	op?: string;
+	task?: string;
+	phase?: string;
+	items?: string[];
+};
+
+/** New single-op shape `{op,...}`; legacy `{ops:[...]}` still seen in old transcripts. */
+type TodoRenderArgs = TodoRenderOp & {
+	ops?: TodoRenderOp[];
 };
 
+/**
+ * Normalize streaming/legacy render args to a flat op list. Accepts the new
+ * top-level `{op,...}` shape (returned as a one-element list), the legacy
+ * `{ops:[...]}` batch from old transcripts/collab-web, and partially-parsed
+ * streaming deltas (non-array `ops`, non-object entries) without crashing.
+ */
+function normalizeTodoArg(args: TodoRenderArgs | undefined): TodoRenderOp[] {
+	if (!args || typeof args !== "object") return [];
+	if (Array.isArray(args.ops)) {
+		return args.ops.filter((entry): entry is TodoRenderOp => !!entry && typeof entry === "object");
+	}
+	return typeof args.op === "string" ? [args] : [];
+}
+
 // =============================================================================
 // Phase numbering (display-only)
 // =============================================================================
@@ -794,7 +791,7 @@ function computeTouchedPhases(
 	for (const transition of completedTasks) touched.add(transition.phase);
 	// Phases explicitly named by the ops that ran. `init` replaces the whole
 	// list, so the entire plan is fresh and every phase counts as touched.
-	const ops = Array.isArray(args?.ops) ? args.ops : [];
+	const ops = normalizeTodoArg(args);
 	for (const op of ops) {
 		if (!op || typeof op !== "object") continue;
 		if (op.op === "init") {
@@ -823,18 +820,17 @@ function formatPhaseSummary(phase: TodoPhase, oneBasedIndex: number, uiTheme: Th
 
 export const todoToolRenderer = {
 	renderCall(args: TodoRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		// `args` here is the raw partially-parsed JSON from the streaming
-		// tool-call delta and may not satisfy `TodoRenderArgs` at runtime:
-		// `parseStreamingJson` can hand back `{ ops: "[" }` mid-delta, or
-		// entries that are `null` / strings before fields stream. Guard
-		// against non-array `ops` and non-object entries so a malformed
-		// delta never breaks the TUI render loop (#2005).
-		const opsList = Array.isArray(args?.ops) ? args.ops : [];
+		// `args` is the raw partially-parsed JSON from the streaming tool-call
+		// delta and may not satisfy `TodoRenderArgs` at runtime:
+		// `parseStreamingJson` can hand back `{ op: 1 }` mid-delta, or a legacy
+		// `{ ops: "[" }` shape before fields stream. `normalizeTodoArg` guards
+		// both the new single-op and legacy batch shapes so a malformed delta
+		// never breaks the TUI render loop (#2005).
+		const opsList = normalizeTodoArg(args);
 		const ops =
 			opsList.length === 0
 				? ["update"]
-				: opsList.map(entry => {
-						const e = entry && typeof entry === "object" ? entry : ({} as NonNullable<typeof entry>);
+				: opsList.map(e => {
 						const parts = [e.op ?? "update"];
 						if (e.task) parts.push(e.task);
 						if (e.phase) parts.push(e.phase);

package/src/tui/code-cell.ts

@@ -80,7 +80,7 @@ function formatHeader(options: CodeCellOptions, theme: Theme): { title: string;
 			parts.push(icon);
 		}
 	}
-	if (index !== undefined && total !== undefined) {
+	if (index !== undefined && total !== undefined && total > 1) {
 		parts.push(theme.fg("accent", `[${index + 1}/${total}]`));
 	}
 	if (title) {

package/src/tui/output-block.ts

@@ -46,6 +46,17 @@ function normalizeContentPaddingLeft(value: number | undefined): number {
 	return Math.max(0, Math.floor(value));
 }
 
+/**
+ * Inner content width that {@link renderOutputBlock} wraps its body to, for a
+ * given outer `width`: both vertical borders (1 cell each) plus the left
+ * content padding. Renderers that size a tail window MUST budget visual rows
+ * against this, not the outer width — otherwise the block re-wraps their lines
+ * into more rows than they counted and the box overflows its intended height.
+ */
+export function outputBlockContentWidth(width: number, contentPaddingLeft?: number): number {
+	return Math.max(1, width - 2 - normalizeContentPaddingLeft(contentPaddingLeft));
+}
+
 export function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[] {
 	const { header, headerMeta, state, sections = [], width, applyBg = true } = options;
 	const h = theme.boxRound.horizontal;

package/src/utils/image-resize.ts

@@ -3,6 +3,8 @@ import type { ImageContent } from "@oh-my-pi/pi-ai";
 export interface ImageResizeOptions {
 	maxWidth?: number;
 	maxHeight?: number;
+	/** Smallest allowed edge length (px). Inputs below this are scaled up. */
+	minDimension?: number;
 	maxBytes?: number;
 	jpegQuality?: number;
 	excludeWebP?: boolean;
@@ -23,6 +25,13 @@ export interface ResizedImage {
 // binding constraint once images are downsized to 1568px (Anthropic's internal threshold).
 const DEFAULT_MAX_BYTES = 500 * 1024;
 
+// Smallest edge length (px) vision backends reliably accept. They tile images into
+// fixed patches (Anthropic uses 28px) and reject degenerate sub-patch images — e.g.
+// the 1x1 PNG an empty chart render emits — with a hard 400 ("Could not process
+// image") that can poison the whole request. 200px is the smallest size Anthropic
+// documents as valid (200x200 = 64 visual tokens); undersized images are scaled up.
+const DEFAULT_MIN_DIMENSION = 200;
+
 const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	// Anthropic's "internal recommended size" — Claude internally caps images at
 	// 1568px on the longest edge before vision processing.
@@ -30,6 +39,7 @@ const DEFAULT_OPTIONS: Required<Omit<ImageResizeOptions, "excludeWebP">> = {
 	maxHeight: 1568,
 	maxBytes: DEFAULT_MAX_BYTES,
 	jpegQuality: 80,
+	minDimension: DEFAULT_MIN_DIMENSION,
 };
 
 /**
@@ -87,7 +97,12 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 		// still get JPEG-compressed.
 		const originalSize = inputBuffer.length;
 		const comfortableSize = opts.maxBytes / 4;
+		// Clamp the floor to the caps so an unusually small max can't demand an
+		// impossible "≥ min and ≤ max" target.
+		const minDimension = Math.min(opts.minDimension, opts.maxWidth, opts.maxHeight);
 		if (
+			originalWidth >= minDimension &&
+			originalHeight >= minDimension &&
 			originalWidth <= opts.maxWidth &&
 			originalHeight <= opts.maxHeight &&
 			originalSize <= comfortableSize &&
@@ -120,6 +135,21 @@ export async function resizeImage(img: ImageContent, options?: ImageResizeOption
 			targetHeight = opts.maxHeight;
 		}
 
+		// Lift undersized inputs up to the minimum. A uniform scale covers the
+		// common case (icons, the 1x1 chart) without distortion; an aspect ratio
+		// too extreme to satisfy both floor and cap falls back to stretching the
+		// lagging edge up to the floor via the default fit:"fill" resize.
+		if (targetWidth < minDimension || targetHeight < minDimension) {
+			const shortEdge = Math.min(targetWidth, targetHeight);
+			const upscale = Math.min(minDimension / shortEdge, opts.maxWidth / targetWidth, opts.maxHeight / targetHeight);
+			if (upscale > 1) {
+				targetWidth = Math.round(targetWidth * upscale);
+				targetHeight = Math.round(targetHeight * upscale);
+			}
+			targetWidth = Math.min(opts.maxWidth, Math.max(minDimension, targetWidth));
+			targetHeight = Math.min(opts.maxHeight, Math.max(minDimension, targetHeight));
+		}
+
 		// First-attempt encoder: try PNG and JPEG (+ WebP if not excluded) — return smallest.
 		// PNG wins for line art / few-color UI; JPEG wins for photographic content;
 		// WebP usually beats JPEG by 25–35% but is disabled when OMP_NO_WEBP is set

package/src/web/search/providers/exa.ts

@@ -7,7 +7,7 @@
  * them into a combined `answer` string on the SearchResponse.
  */
 import { type ApiKey, type AuthStorage, type FetchImpl, getEnvApiKey, withAuth } from "@oh-my-pi/pi-ai";
-import { settings } from "../../../config/settings";
+import { getDefault, settings } from "../../../config/settings";
 import { findApiKey, isSearchResponse } from "../../../exa/mcp-client";
 import { parseSSE } from "../../../mcp/json-rpc";
 import type { SearchResponse, SearchSource } from "../../../web/search/types";
@@ -18,6 +18,88 @@ import { SearchProvider } from "./base";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const EXA_API_URL = "https://api.exa.ai/search";
+const DEFAULT_EXA_SEARCH_DELAY_MS = getDefault("exa.searchDelayMs");
+
+let nextExaSearchRequestAt = 0;
+let exaSearchThrottle = Promise.resolve();
+
+function configuredExaSearchDelayMs(): number {
+	try {
+		const delayMs = settings.get("exa.searchDelayMs");
+		return Number.isFinite(delayMs) && delayMs > 0 ? Math.floor(delayMs) : 0;
+	} catch {
+		return DEFAULT_EXA_SEARCH_DELAY_MS;
+	}
+}
+
+function rejectWithAbortReason(reject: (reason?: unknown) => void, signal: AbortSignal): void {
+	try {
+		signal.throwIfAborted();
+		reject(new DOMException("The operation was aborted.", "AbortError"));
+	} catch (error) {
+		reject(error);
+	}
+}
+
+function abortableSleep(ms: number, signal: AbortSignal | undefined): Promise<void> {
+	if (ms <= 0) return Promise.resolve();
+	signal?.throwIfAborted();
+	const { promise, resolve, reject } = Promise.withResolvers<void>();
+	let timer: NodeJS.Timeout | undefined;
+	const cleanup = (): void => {
+		if (timer) {
+			clearTimeout(timer);
+			timer = undefined;
+		}
+		signal?.removeEventListener("abort", onAbort);
+	};
+	const onAbort = (): void => {
+		cleanup();
+		if (signal) rejectWithAbortReason(reject, signal);
+	};
+	timer = setTimeout(() => {
+		cleanup();
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+	if (signal?.aborted) onAbort();
+	return promise;
+}
+
+function waitUntilDoneOrAborted<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+	if (!signal) return promise;
+	signal.throwIfAborted();
+	const { promise: aborted, reject } = Promise.withResolvers<never>();
+	const onAbort = (): void => rejectWithAbortReason(reject, signal);
+	signal.addEventListener("abort", onAbort, { once: true });
+	return Promise.race([promise, aborted]).finally(() => {
+		signal.removeEventListener("abort", onAbort);
+	});
+}
+
+async function waitForExaSearchSlot(signal: AbortSignal | undefined): Promise<void> {
+	const delayMs = configuredExaSearchDelayMs();
+	if (delayMs <= 0) return;
+
+	const prior = exaSearchThrottle.catch(() => {});
+	const queued = prior.then(async () => {
+		signal?.throwIfAborted();
+		const waitMs = Math.max(0, nextExaSearchRequestAt - Date.now());
+		if (waitMs > 0) {
+			await abortableSleep(waitMs, signal);
+		}
+		signal?.throwIfAborted();
+		nextExaSearchRequestAt = Date.now() + delayMs;
+	});
+	exaSearchThrottle = queued.catch(() => {});
+	await waitUntilDoneOrAborted(queued, signal);
+}
+
+/** Reset Exa request pacing state for isolated provider tests. */
+export function resetExaSearchThrottleForTest(): void {
+	nextExaSearchRequestAt = 0;
+	exaSearchThrottle = Promise.resolve();
+}
 
 type ExaSearchType = "neural" | "fast" | "auto" | "deep";
 
@@ -224,6 +306,7 @@ async function callExaSearch(apiKey: string, params: ExaSearchParams): Promise<E
 	const body = buildExaRequestBody(params);
 
 	const fetchImpl = params.fetch ?? fetch;
+	await waitForExaSearchSlot(params.signal);
 	const response = await fetchImpl(EXA_API_URL, {
 		method: "POST",
 		headers: {
@@ -260,6 +343,7 @@ async function callExaMcpSearch(params: ExaSearchParams): Promise<ExaSearchRespo
 	if (apiKey) query.set("exaApiKey", apiKey);
 	query.set("tools", "web_search_exa");
 	const fetchImpl = params.fetch ?? fetch;
+	await waitForExaSearchSlot(params.signal);
 	const response = await fetchImpl(`https://mcp.exa.ai/mcp?${query.toString()}`, {
 		method: "POST",
 		headers: {