@oh-my-pi/pi-coding-agent 16.0.5 → 16.0.7

package/src/tools/read.ts

@@ -1,5 +1,6 @@
 import { Database } from "bun:sqlite";
 import * as fs from "node:fs/promises";
+import * as os from "node:os";
 import * as path from "node:path";
 import { formatHashlineHeader, formatNumberedLine, formatNumberedLines } from "@oh-my-pi/hashline";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
@@ -8,8 +9,8 @@ import { glob, type SummaryResult, summarizeCode } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { getRemoteDir, logger, prompt, readImageMetadata, untilAborted } from "@oh-my-pi/pi-utils";
+import { type } from "arktype";
 import { LRUCache } from "lru-cache/raw";
-import { z } from "zod/v4";
 import {
 	canonicalSnapshotKey,
 	getFileSnapshotStore,
@@ -661,18 +662,40 @@ function prependSuffixResolutionNotice(text: string, suffixResolution?: { from:
 	const notice = `[Path '${suffixResolution.from}' not found; resolved to '${suffixResolution.to}' via suffix match]`;
 	return text ? `${notice}\n${text}` : notice;
 }
+const PDF_IMAGE_PLACEHOLDER_RE = /<!--\s*image:\s*([^\s<>]+)(.*?)-->/g;
+const PDF_IMAGE_MEMBER_RE = /^(.*\.pdf):(.*)$/i;
+const PDF_IMAGE_MEMBER_EXTENSION_RE = /\.png$/i;
 
-const readSchema = z
-	.object({
-		path: z
-			.string()
-			.describe(
-				'Local path, internal URI (e.g. "omp://", "issue://123", "pr://123"), or URL; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")',
-			),
-	})
-	.strict();
+function pdfImageMemberPath(pdfPath: string, imageId: string): string {
+	const member = PDF_IMAGE_MEMBER_EXTENSION_RE.test(imageId) ? imageId : `${imageId}.png`;
+	return `${pdfPath}:${member}`;
+}
+
+function rewritePdfImagePlaceholders(markdown: string, pdfPath: string): string {
+	return markdown.replace(PDF_IMAGE_PLACEHOLDER_RE, (_match: string, imageId: string, metadataText: string) => {
+		const metadata = metadataText.trim();
+		const suffix = metadata.length > 0 ? ` (${metadata})` : "";
+		return `Image ${imageId}${suffix}: read \`${pdfImageMemberPath(pdfPath, imageId)}\``;
+	});
+}
+
+function splitPdfImageMemberReadPath(readPath: string): { pdfPath: string; member: string } | null {
+	const match = PDF_IMAGE_MEMBER_RE.exec(readPath);
+	if (!match) return null;
+	const pdfPath = match[1];
+	const member = match[2];
+	if (pdfPath === undefined || member === undefined) return null;
+	if (member.length !== 0 && !PDF_IMAGE_MEMBER_EXTENSION_RE.test(member)) return null;
+	return { pdfPath, member };
+}
+
+const readSchema = type({
+	path: type("string").describe(
+		'Local path, internal URI (e.g. "omp://", "issue://123", "pr://123"), or URL; append :<sel> for line ranges or raw mode (e.g. "src/foo.ts:50-100")',
+	),
+});
 
-export type ReadToolInput = z.infer<typeof readSchema>;
+export type ReadToolInput = typeof readSchema.infer;
 
 export interface ReadToolDetails {
 	kind?: "file" | "url";
@@ -983,6 +1006,113 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		return null;
 	}
 
+	#pdfImageCacheDir(absolutePdfPath: string): string {
+		const artifactsDir = this.session.getArtifactsDir?.();
+		let root = artifactsDir ?? undefined;
+		if (root === undefined) {
+			const sessionFile = this.session.getSessionFile();
+			root = sessionFile?.endsWith(".jsonl")
+				? sessionFile.slice(0, -6)
+				: path.join(os.tmpdir(), "omp-read-pdf-images");
+		}
+		const basename = path.basename(absolutePdfPath).replace(/[^A-Za-z0-9._-]/g, "_");
+		return path.join(root, "read-pdf-images", `${basename}-${Bun.hash(absolutePdfPath).toString(36)}`);
+	}
+
+	async #listPdfImageMembers(imageDir: string): Promise<string[]> {
+		try {
+			const entries = await fs.readdir(imageDir, { withFileTypes: true });
+			const members: string[] = [];
+			for (const entry of entries) {
+				if (entry.isFile() && PDF_IMAGE_MEMBER_EXTENSION_RE.test(entry.name)) members.push(entry.name);
+			}
+			return members.sort();
+		} catch (error) {
+			if (isNotFoundError(error)) return [];
+			throw error;
+		}
+	}
+
+	async #ensurePdfImageCache(absolutePdfPath: string, signal?: AbortSignal): Promise<string> {
+		const imageDir = this.#pdfImageCacheDir(absolutePdfPath);
+		const markerPath = path.join(imageDir, ".extracted");
+		try {
+			await fs.stat(markerPath);
+			return imageDir;
+		} catch (error) {
+			if (!isNotFoundError(error)) throw error;
+		}
+
+		await fs.rm(imageDir, { recursive: true, force: true });
+		await fs.mkdir(imageDir, { recursive: true });
+		const result = await convertFileWithMarkit(absolutePdfPath, signal, { imageDir });
+		if (!result.ok) {
+			await fs.rm(imageDir, { recursive: true, force: true });
+			throw new ToolError(`Cannot extract images from PDF: ${result.error ?? "conversion failed"}`);
+		}
+		await Bun.write(markerPath, "ok");
+		return imageDir;
+	}
+
+	async #readPdfImageMember(
+		absolutePdfPath: string,
+		pdfDisplayPath: string,
+		member: string,
+		suffixResolution: { from: string; to: string } | undefined,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<ReadToolDetails>> {
+		const imageDir = await this.#ensurePdfImageCache(absolutePdfPath, signal);
+		const members = await this.#listPdfImageMembers(imageDir);
+		if (member.length === 0) {
+			const text =
+				members.length === 0
+					? "No extractable PDF image members found."
+					: `Extractable PDF image members:\n${members
+							.map(imageMember => `- read \`${pdfDisplayPath}:${imageMember}\``)
+							.join("\n")}`;
+			return toolResult<ReadToolDetails>({ resolvedPath: absolutePdfPath, suffixResolution })
+				.text(prependSuffixResolutionNotice(text, suffixResolution))
+				.sourcePath(absolutePdfPath)
+				.done();
+		}
+
+		if (!members.includes(member)) {
+			const available = members.length === 0 ? "(none)" : members.join(", ");
+			throw new ToolError(`PDF image member '${member}' not found. Available members: ${available}`);
+		}
+
+		const imagePath = path.join(imageDir, member);
+		const imageStat = await Bun.file(imagePath).stat();
+		if (imageStat.size > MAX_IMAGE_SIZE) {
+			const sizeStr = formatBytes(imageStat.size);
+			const maxStr = formatBytes(MAX_IMAGE_SIZE);
+			throw new ToolError(`Image file too large: ${sizeStr} exceeds ${maxStr} limit.`);
+		}
+		const metadata = await readImageMetadata(imagePath);
+		const mimeType = metadata?.mimeType;
+		if (!mimeType) throw new ToolError(`PDF image member '${member}' is not a supported image.`);
+		const imageInput = await loadImageInput({
+			path: `${pdfDisplayPath}:${member}`,
+			cwd: this.session.cwd,
+			autoResize: this.#autoResizeImages,
+			maxBytes: MAX_IMAGE_SIZE,
+			resolvedPath: imagePath,
+			detectedMimeType: mimeType,
+			excludeWebP: webpExclusionForModel(this.session.getActiveModel?.()),
+		});
+		if (!imageInput) {
+			throw new ToolError(`Read image file [${mimeType}] failed: unsupported image format.`);
+		}
+		const textNote = prependSuffixResolutionNotice(imageInput.textNote, suffixResolution);
+		return toolResult<ReadToolDetails>({ resolvedPath: absolutePdfPath, suffixResolution })
+			.content([
+				{ type: "text", text: textNote },
+				{ type: "image", data: imageInput.data, mimeType: imageInput.mimeType },
+			])
+			.sourcePath(imageInput.resolvedPath)
+			.done();
+	}
+
 	#buildInMemoryTextResult(
 		text: string,
 		offset: number | undefined,
@@ -1905,6 +2035,30 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return this.#readSqlite(sqlitePath, signal);
 		}
 
+		const pdfImageMemberPath = splitPdfImageMemberReadPath(readPath);
+		if (pdfImageMemberPath) {
+			let absolutePdfPath = resolveReadPath(pdfImageMemberPath.pdfPath, this.session.cwd);
+			let suffixResolution: { from: string; to: string } | undefined;
+			try {
+				const stat = await Bun.file(absolutePdfPath).stat();
+				if (stat.isDirectory())
+					throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' is a directory, not a PDF file`);
+			} catch (error) {
+				if (!isNotFoundError(error) || isRemoteMountPath(absolutePdfPath)) throw error;
+				const suffixMatch = await this.#findSuffixMatchCached(suffixCache, pdfImageMemberPath.pdfPath, signal);
+				if (!suffixMatch) throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' not found`);
+				absolutePdfPath = suffixMatch.absolutePath;
+				suffixResolution = { from: pdfImageMemberPath.pdfPath, to: suffixMatch.displayPath };
+			}
+			return this.#readPdfImageMember(
+				absolutePdfPath,
+				pdfImageMemberPath.pdfPath,
+				pdfImageMemberPath.member,
+				suffixResolution,
+				signal,
+			);
+		}
+
 		const localTarget = splitPathAndSel(readPath);
 		const localReadPath = localTarget.path;
 		const parsed = parseSel(localTarget.sel);
@@ -2056,20 +2210,22 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			// Convert document via markit.
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
+				const renderedContent =
+					ext === ".pdf" ? rewritePdfImagePlaceholders(result.content, localReadPath) : result.content;
 				// Route the converted markdown through the in-memory text builder
 				// so line-range selectors (`file.pdf:50-100`, `:5-16,40-80`) and
 				// raw mode apply against the converted output. Without this,
 				// `file.pdf:50-100` silently returned the head of the document
 				// because only `truncateHead` was being applied.
 				if (isMultiRange(parsed) && parsed.kind === "lines") {
-					return this.#buildInMemoryMultiRangeResult(result.content, parsed.ranges, {
+					return this.#buildInMemoryMultiRangeResult(renderedContent, parsed.ranges, {
 						details: { resolvedPath: absolutePath },
 						sourcePath: absolutePath,
 						entityLabel: "document",
 					});
 				}
 				const { offset, limit } = selToOffsetLimit(parsed);
-				return this.#buildInMemoryTextResult(result.content, offset, limit, {
+				return this.#buildInMemoryTextResult(renderedContent, offset, limit, {
 					details: { resolvedPath: absolutePath },
 					sourcePath: absolutePath,
 					entityLabel: "document",

package/src/tools/report-tool-issue.ts

@@ -23,7 +23,7 @@ import { Database } from "bun:sqlite";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { FetchImpl } from "@oh-my-pi/pi-ai";
 import { $env, $flag, getAutoQaDbDir, getInstallId, logger, VERSION } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { Settings } from "..";
 import type { ToolSession } from "./index";
 
@@ -31,12 +31,12 @@ function buildReportToolIssueParams(activeBuiltinNames: readonly string[]) {
 	// Enum gives the model a tight schema; the runtime check in `execute` is the
 	// source of truth (handles models that ignore the enum and the empty-list
 	// fallback used by call sites that don't know the active set yet).
-	const toolSchema = activeBuiltinNames.length > 0 ? z.enum(activeBuiltinNames as [string, ...string[]]) : z.string();
-	return z.object({
+	const toolSchema = activeBuiltinNames.length > 0 ? type.enumerated(...activeBuiltinNames) : type("string");
+	return type({
 		tool: toolSchema.describe("tool name"),
-		report: z
-			.string()
-			.describe("unexpected behavior; generic, NEVER PII (paths, file contents, identifiers, prompt text)"),
+		report: type("string").describe(
+			"unexpected behavior; generic, NEVER PII (paths, file contents, identifiers, prompt text)",
+		),
 	});
 }
 

package/src/tools/resolve.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 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 { z } from "zod/v4";
+import { type } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import resolveDescription from "../prompts/tools/resolve.md" with { type: "text" };
@@ -11,13 +11,13 @@ import type { ToolSession } from ".";
 import { replaceTabs } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-const resolveSchema = z.object({
-	action: z.enum(["apply", "discard"]),
-	reason: z.string().describe("reason for action"),
-	extra: z.record(z.string(), z.unknown()).optional().describe("free-form metadata"),
+const resolveSchema = type({
+	action: "'apply' | 'discard'",
+	reason: type("string").describe("reason for action"),
+	"extra?": type("Record<string, unknown>").describe("free-form metadata"),
 });
 
-type ResolveParams = z.infer<typeof resolveSchema>;
+type ResolveParams = typeof resolveSchema.infer;
 
 export interface ResolveToolDetails {
 	action: "apply" | "discard";

package/src/tools/review.ts

@@ -12,7 +12,7 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Container, Text } from "@oh-my-pi/pi-tui";
 import { isRecord } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { Theme, ThemeColor } from "../modes/theme/theme";
 import { subprocessToolRegistry } from "../task/subprocess-tool-registry";
 import type { ReviewFinding } from "../task/types";
@@ -52,17 +52,15 @@ function getPriorityDisplay(
 
 // report_finding schema
 // report_finding schema
-const ReportFindingParams = z
-	.object({
-		title: z.string().describe("prefixed imperative title"),
-		body: z.string().describe("problem explanation"),
-		priority: z.enum(["P0", "P1", "P2", "P3"] as const).describe("priority 0-3"),
-		confidence: z.number().min(0).max(1).describe("confidence score"),
-		file_path: z.string().describe("file path"),
-		line_start: z.number().describe("start line"),
-		line_end: z.number().describe("end line"),
-	})
-	.strict();
+const ReportFindingParams = type({
+	title: type("string").describe("prefixed imperative title"),
+	body: type("string").describe("problem explanation"),
+	priority: type("'P0' | 'P1' | 'P2' | 'P3'").describe("priority 0-3"),
+	confidence: type("number >= 0 & number <= 1").describe("confidence score"),
+	file_path: type("string").describe("file path"),
+	line_start: type("number").describe("start line"),
+	line_end: type("number").describe("end line"),
+});
 
 interface ReportFindingDetails {
 	title: string;

package/src/tools/search-tool-bm25.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import searchToolBm25Description from "../prompts/tools/search-tool-bm25.md" with { type: "text" };
@@ -27,12 +27,12 @@ const COLLAPSED_MATCH_LIMIT = 5;
 const MATCH_LABEL_LEN = 72;
 const MATCH_DESCRIPTION_LEN = 96;
 
-const searchToolBm25Schema = z.object({
-	query: z.string().describe("tool search query"),
-	limit: z.number().int().min(1).optional().describe("max matches"),
+const searchToolBm25Schema = type({
+	query: type("string").describe("tool search query"),
+	"limit?": type("number>0").describe("max matches"),
 });
 
-type SearchToolBm25Params = z.infer<typeof searchToolBm25Schema>;
+type SearchToolBm25Params = typeof searchToolBm25Schema.infer;
 
 interface SearchToolBm25Match {
 	name: string;

package/src/tools/search.ts

@@ -7,7 +7,7 @@ import { type GrepMatch, GrepOutputMode, type GrepResult, grep } from "@oh-my-pi
 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 { z } from "zod/v4";
+import { type } from "arktype";
 import { recordFileSnapshot, recordSeenLinesFromBody } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { LocalProtocolOptions } from "../internal-urls/local-protocol";
@@ -65,31 +65,24 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const searchPathEntrySchema = z
-	.string()
-	.describe(
-		'file, directory, glob, internal URL, or "<file>:<lines>" selector (e.g. "src/foo.ts:50-100", "src/foo.ts:50+10", "src/foo.ts:50-100,200-300")',
-	);
-const searchSchema = z
-	.object({
-		pattern: z.string().describe("regex pattern"),
-		paths: z
-			.union([searchPathEntrySchema, z.array(searchPathEntrySchema)])
-			.optional()
-			.describe(
-				'file, directory, glob, internal URL, or array of those to search; append `:<lines>` to scope a file to specific line ranges. Omitted or empty -> searches the workspace root (".")',
-			),
-		i: z.boolean().optional().describe("case-insensitive search"),
-		gitignore: z.boolean().optional().describe("respect gitignore"),
-		skip: z
-			.number()
-			.nullable()
-			.optional()
-			.describe("files to skip before collecting results — use to paginate when the prior call hit the file limit"),
-	})
-	.strict();
-
-export type SearchToolInput = z.infer<typeof searchSchema>;
+const searchPathEntry = type("string").describe(
+	'file, directory, glob, internal URL, or "<file>:<lines>" selector (e.g. "src/foo.ts:50-100", "src/foo.ts:50+10", "src/foo.ts:50-100,200-300")',
+);
+const searchSchema = type({
+	pattern: type("string").describe("regex pattern"),
+	"paths?": searchPathEntry
+		.or(searchPathEntry.array())
+		.describe(
+			'file, directory, glob, internal URL, or array of those to search; append `:<lines>` to scope a file to specific line ranges. Omitted or empty -> searches the workspace root (".")',
+		),
+	"i?": type("boolean").describe("case-insensitive search"),
+	"gitignore?": type("boolean").describe("respect gitignore"),
+	"skip?": type("number")
+		.or("null")
+		.describe("files to skip before collecting results — use to paginate when the prior call hit the file limit"),
+});
+
+export type SearchToolInput = typeof searchSchema.infer;
 export function toPathList(input: string | string[] | undefined): string[] {
 	return typeof input === "string" ? [input] : (input ?? []);
 }
@@ -665,7 +658,7 @@ export interface SearchToolDetails {
 	missingPaths?: string[];
 }
 
-type SearchParams = z.infer<typeof searchSchema>;
+type SearchParams = typeof searchSchema.infer;
 
 export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDetails> {
 	readonly name = "search";
@@ -884,7 +877,6 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 										multiline: effectiveMultiline,
 										hidden: true,
 										gitignore: useGitignore,
-										cache: false,
 										maxCount: INTERNAL_TOTAL_CAP,
 										contextBefore: normalizedContextBefore,
 										contextAfter: normalizedContextAfter,
@@ -932,7 +924,6 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 									multiline: effectiveMultiline,
 									hidden: true,
 									gitignore: useGitignore,
-									cache: false,
 									maxCount: INTERNAL_TOTAL_CAP,
 									contextBefore: normalizedContextBefore,
 									contextAfter: normalizedContextAfter,

package/src/tools/ssh.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { SSHHost } from "../capability/ssh";
 import { sshCapability } from "../capability/ssh";
 import { loadCapability } from "../discovery";
@@ -23,11 +23,11 @@ import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
-const sshSchema = z.object({
-	host: z.string().describe("ssh host"),
-	command: z.string().describe("remote command"),
-	cwd: z.string().optional().describe("remote working directory"),
-	timeout: z.number().optional().describe("timeout in seconds").default(60),
+const sshSchema = type({
+	host: type("string").describe("ssh host"),
+	command: type("string").describe("remote command"),
+	"cwd?": type("string").describe("remote working directory"),
+	"timeout?": type("number").describe("timeout in seconds"),
 });
 
 export interface SSHToolDetails {
@@ -118,7 +118,7 @@ async function loadHosts(session: ToolSession): Promise<{
 	return { hostNames, hostsByName };
 }
 
-type SshToolParams = z.infer<typeof sshSchema>;
+type SshToolParams = typeof sshSchema.infer;
 
 export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	readonly name = "ssh";
@@ -136,7 +136,7 @@ export class SshTool implements AgentTool<typeof sshSchema, SSHToolDetails> {
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof sshSchema>>[] = [
+	readonly examples: readonly ToolExample<SshToolParams>[] = [
 		{
 			caption: "List files: Linux (on server1 (10.0.0.1) | linux/bash)",
 			call: { host: "server1", command: "ls -la /home/user" },

package/src/tools/todo.ts

@@ -3,8 +3,8 @@ import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
+import { type } from "arktype";
 import chalk from "chalk";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoDescription from "../prompts/tools/todo.md" with { type: "text" };
@@ -44,30 +44,27 @@ export interface TodoToolDetails {
 // Schema
 // =============================================================================
 
-const TodoOp = z
-	.enum(["init", "start", "done", "rm", "drop", "append", "view"] as const)
-	.describe("operation to apply");
+const TodoOp = type('"init" | "start" | "done" | "rm" | "drop" | "append" | "view"').describe("operation to apply");
 
-const InitListEntry = z.object({
-	phase: z.string().describe("phase name"),
-	items: z.array(z.string().describe("task content")).min(1).describe("tasks for this phase"),
+const InitListEntry = type({
+	phase: type("string").describe("phase name"),
+	items: type("string").describe("task content").array().atLeastLength(1).describe("tasks for this phase"),
 });
 
-const TodoOpEntry = z.object({
+const TodoOpEntry = type({
 	op: TodoOp,
-	list: z.array(InitListEntry).optional().describe("phased task list (init)"),
-	task: z.string().optional().describe("task content"),
-	phase: z.string().optional().describe("phase name"),
-	items: z.array(z.string().describe("task content")).min(1).optional().describe("tasks to append"),
+	"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 = z
-	.object({
-		ops: z.array(TodoOpEntry).min(1).describe("ordered todo operations"),
-	})
-	.describe("apply ordered todo operations");
+const todoSchema = type({
+	ops: TodoOpEntry.array().atLeastLength(1).describe("ordered todo operations"),
+}).describe("apply ordered todo operations");
 
-type TodoParams = z.infer<typeof todoSchema>;
+type TodoParams = TodoSchema;
+type TodoSchema = typeof todoSchema.infer;
 type TodoOpEntryValue = TodoParams["ops"][number];
 
 // =============================================================================
@@ -565,7 +562,7 @@ export class TodoTool implements AgentTool<typeof todoSchema, TodoToolDetails> {
 	readonly concurrency = "exclusive";
 	readonly strict = true;
 
-	readonly examples: readonly ToolExample<z.input<typeof todoSchema>>[] = [
+	readonly examples: readonly ToolExample<typeof todoSchema.infer>[] = [
 		{
 			caption: "Initial setup (multi-phase)",
 			call: {

package/src/tools/tts.ts

@@ -5,7 +5,7 @@
 
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { type ApiKey, ProviderHttpError, withAuth } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { settings } from "../config/settings";
 import type { CustomTool, CustomToolContext } from "../extensibility/custom-tools/types";
 import { ohMyPiXAIUserAgent, resolveXAIHttpCredentials } from "../lib/xai-http";
@@ -16,7 +16,6 @@ import { formatPathRelativeToCwd, resolveToCwd } from "./path-utils";
 
 // Hermes tts_tool.py L167-171
 const DEFAULT_XAI_VOICE_ID = "eve" as const;
-const DEFAULT_XAI_LANGUAGE = "en" as const;
 const DEFAULT_XAI_SAMPLE_RATE = 24_000;
 const DEFAULT_XAI_BIT_RATE = 128_000;
 const XAI_MAX_TEXT_LENGTH = 15_000;
@@ -31,15 +30,17 @@ const formatVoiceList = (): string =>
 type TtsCodec = "mp3" | "wav";
 type TtsBackend = "local" | "xai";
 
-const ttsSchema = z.object({
-	text: z.string().min(1).max(XAI_MAX_TEXT_LENGTH),
-	voice_id: z.string().default(DEFAULT_XAI_VOICE_ID),
-	language: z.string().default(DEFAULT_XAI_LANGUAGE),
-	output_path: z.string(),
-	sample_rate: z.number().int().optional(),
-	bit_rate: z.number().int().optional(),
+const ttsSchema = type({
+	text: "1 <= string <= 15000",
+	voice_id: "string = 'eve'",
+	language: "string = 'en'",
+	output_path: "string",
+	sample_rate: "number.integer?",
+	bit_rate: "number.integer?",
 });
 
+type TtsSchemaType = typeof ttsSchema.infer;
+
 interface TtsToolDetails {
 	bytes: number;
 	voiceId: string;
@@ -87,13 +88,13 @@ function readStringSetting(key: "providers.tts" | "tts.localModel" | "tts.localV
 }
 
 async function synthesizeXai(
-	params: z.infer<typeof ttsSchema>,
+	params: TtsSchemaType,
 	ctx: CustomToolContext,
 	outputPath: string,
 	displayPath: string,
 	codec: TtsCodec,
 	signal: AbortSignal | undefined,
-): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 	const creds = await resolveXAIHttpCredentials(ctx.modelRegistry);
 	if (!creds) {
 		return {
@@ -187,11 +188,11 @@ async function synthesizeXai(
 }
 
 async function synthesizeLocal(
-	params: z.infer<typeof ttsSchema>,
+	params: TtsSchemaType,
 	cwd: string,
 	outputPath: string,
 	signal: AbortSignal | undefined,
-): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 	const modelSetting = readStringSetting("tts.localModel");
 	const modelKey = modelSetting && isTtsLocalModelKey(modelSetting) ? modelSetting : DEFAULT_TTS_LOCAL_MODEL_KEY;
 	const voice = readStringSetting("tts.localVoice") || DEFAULT_TTS_VOICE;
@@ -242,11 +243,11 @@ export const ttsTool: CustomTool<typeof ttsSchema, TtsToolDetails> = {
 	parameters: ttsSchema,
 	async execute(
 		_toolCallId: string,
-		params: z.infer<typeof ttsSchema>,
+		params: TtsSchemaType,
 		_onUpdate,
 		ctx: CustomToolContext,
 		signal?: AbortSignal,
-	): Promise<AgentToolResult<TtsToolDetails, typeof ttsSchema>> {
+	): Promise<AgentToolResult<TtsToolDetails, TtsSchemaType>> {
 		const cwd = ctx.sessionManager.getCwd();
 		const outputPath = resolveToCwd(params.output_path, cwd);
 		const displayPath = formatPathRelativeToCwd(outputPath, cwd);