@oh-my-pi/pi-coding-agent 15.0.1 → 15.1.0

package/src/tools/browser.ts

@@ -1,7 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { acquireBrowser, type BrowserHandle, type BrowserKind, type BrowserKindTag } from "./browser/registry";
@@ -18,62 +17,49 @@ export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 
 const DEFAULT_TAB_NAME = "main";
 
-const appSchema = Type.Object({
-	path: Type.Optional(
-		Type.String({
-			description: "absolute path to a binary to spawn (single-instance reuse)",
-			examples: ["/Applications/Cursor.app/Contents/MacOS/Cursor"],
-		}),
-	),
-	cdp_url: Type.Optional(
-		Type.String({
-			description: "existing CDP endpoint to connect to (e.g. http://127.0.0.1:9222)",
-		}),
-	),
-	args: Type.Optional(Type.Array(Type.String(), { description: "extra CLI args when spawning" })),
-	target: Type.Optional(Type.String({ description: "substring matched against url+title to pick a BrowserWindow" })),
+const appSchema = z.object({
+	path: z.string().describe("absolute path to a binary to spawn (single-instance reuse)").optional(),
+	cdp_url: z.string().describe("existing CDP endpoint to connect to (e.g. http://127.0.0.1:9222)").optional(),
+	args: z.array(z.string()).describe("extra CLI args when spawning").optional(),
+	target: z.string().describe("substring matched against url+title to pick a BrowserWindow").optional(),
 });
 
-const browserSchema = Type.Object({
-	action: StringEnum(["open", "close", "run"], { description: "tab/browser operation" }),
-	name: Type.Optional(
-		Type.String({
-			description: "tab id; default 'main'. Multiple tabs can coexist; reusable across run() calls and subagents.",
-			examples: ["main", "docs", "gh"],
-		}),
-	),
-	url: Type.Optional(Type.String({ description: "open: navigate after acquiring tab" })),
-	app: Type.Optional(appSchema),
-	viewport: Type.Optional(
-		Type.Object({
-			width: Type.Number(),
-			height: Type.Number(),
-			scale: Type.Optional(Type.Number()),
-		}),
-	),
-	wait_until: Type.Optional(
-		StringEnum(["load", "domcontentloaded", "networkidle0", "networkidle2"], {
-			description: "navigation wait condition for url",
-		}),
-	),
-	dialogs: Type.Optional(
-		StringEnum(["accept", "dismiss"], {
-			description: "open: auto-handle alert/confirm/beforeunload dialogs (default: leave for caller to handle)",
-		}),
-	),
-	code: Type.Optional(
-		Type.String({
-			description:
-				"run: JS body executed with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. Treated as the body of an async function. Use `display(value)` to attach text/JSON/images; the function's return value is JSON-serialized as a final block.",
-		}),
-	),
-	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 30 })),
-	all: Type.Optional(Type.Boolean({ description: "close: close every tab" })),
-	kill: Type.Optional(Type.Boolean({ description: "close: also kill spawned-app browsers (default: leave running)" })),
+const browserSchema = z.object({
+	action: z.enum(["open", "close", "run"] as const).describe("tab/browser operation"),
+	name: z
+		.string()
+		.describe("tab id; default 'main'. Multiple tabs can coexist; reusable across run() calls and subagents.")
+		.optional(),
+	url: z.string().describe("open: navigate after acquiring tab").optional(),
+	app: appSchema.optional(),
+	viewport: z
+		.object({
+			width: z.number(),
+			height: z.number(),
+			scale: z.number().optional(),
+		})
+		.optional(),
+	wait_until: z
+		.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"] as const)
+		.describe("navigation wait condition for url")
+		.optional(),
+	dialogs: z
+		.enum(["accept", "dismiss"] as const)
+		.describe("open: auto-handle alert/confirm/beforeunload dialogs (default: leave for caller to handle)")
+		.optional(),
+	code: z
+		.string()
+		.describe(
+			"run: JS body executed with `page`, `browser`, `tab`, `display`, `assert`, `wait` in scope. Treated as the body of an async function. Use `display(value)` to attach text/JSON/images; the function's return value is JSON-serialized as a final block.",
+		)
+		.optional(),
+	timeout: z.number().default(30).describe("timeout in seconds").optional(),
+	all: z.boolean().describe("close: close every tab").optional(),
+	kill: z.boolean().describe("close: also kill spawned-app browsers (default: leave running)").optional(),
 });
 
 /** Input schema for the browser tool. */
-export type BrowserParams = Static<typeof browserSchema>;
+export type BrowserParams = z.infer<typeof browserSchema>;
 
 /** Details describing a browser tool execution result (for renderers + transcript). */
 export interface BrowserToolDetails {

package/src/tools/calculator.ts

@@ -2,7 +2,7 @@ import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 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 * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import calculatorDescription from "../prompts/tools/calculator.md" with { type: "text" };
@@ -28,15 +28,16 @@ type Token =
 	| { type: "operator"; value: Operator }
 	| { type: "paren"; value: "(" | ")" };
 
-const calculatorSchema = Type.Object({
-	calculations: Type.Array(
-		Type.Object({
-			expression: Type.String({ description: "math expression", examples: ["2 + 2", "sqrt(16)"] }),
-			prefix: Type.String({ description: "prefix text" }),
-			suffix: Type.String({ description: "suffix text" }),
-		}),
-		{ description: "calculations to evaluate" },
-	),
+const calculatorSchema = z.object({
+	calculations: z
+		.array(
+			z.object({
+				expression: z.string().describe("math expression"),
+				prefix: z.string().describe("prefix text"),
+				suffix: z.string().describe("suffix text"),
+			}),
+		)
+		.describe("calculations to evaluate"),
 });
 
 export interface CalculatorToolDetails {
@@ -385,7 +386,7 @@ function formatResult(value: number): string {
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
 
-type CalculatorParams = Static<typeof calculatorSchema>;
+type CalculatorParams = z.infer<typeof calculatorSchema>;
 
 /**
  * Calculator tool for evaluating mathematical expressions.

package/src/tools/checkpoint.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import checkpointDescription from "../prompts/tools/checkpoint.md" with { type: "text" };
 import rewindDescription from "../prompts/tools/rewind.md" with { type: "text" };
 import type { ToolSession } from ".";
@@ -17,17 +17,17 @@ export interface CheckpointState {
 	startedAt: string;
 }
 
-const checkpointSchema = Type.Object({
-	goal: Type.String({ description: "investigation goal", examples: ["investigate retry logic"] }),
+const checkpointSchema = z.object({
+	goal: z.string().describe("investigation goal"),
 });
 
-type CheckpointParams = Static<typeof checkpointSchema>;
+type CheckpointParams = z.infer<typeof checkpointSchema>;
 
-const rewindSchema = Type.Object({
-	report: Type.String({ description: "investigation findings" }),
+const rewindSchema = z.object({
+	report: z.string().describe("investigation findings"),
 });
 
-type RewindParams = Static<typeof rewindSchema>;
+type RewindParams = z.infer<typeof rewindSchema>;
 
 export interface CheckpointToolDetails {
 	goal: string;

package/src/tools/debug.ts

@@ -5,10 +5,9 @@ import type {
 	AgentToolUpdateCallback,
 	RenderResultOptions,
 } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import {
 	type DapBreakpointRecord,
 	type DapCapabilities,
@@ -51,8 +50,8 @@ import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
-const debugSchema = Type.Object({
-	action: StringEnum([
+const debugSchema = z.object({
+	action: z.enum([
 		"launch",
 		"attach",
 		"set_breakpoint",
@@ -81,47 +80,45 @@ const debugSchema = Type.Object({
 		"output",
 		"terminate",
 		"sessions",
-	]),
-	program: Type.Optional(Type.String({ description: "program path" })),
-	args: Type.Optional(Type.Array(Type.String(), { description: "program arguments" })),
-	adapter: Type.Optional(Type.String({ description: "debugger adapter (gdb, lldb-dap, debugpy, dlv)" })),
-	cwd: Type.Optional(Type.String()),
-	file: Type.Optional(Type.String({ description: "source file" })),
-	line: Type.Optional(Type.Number({ description: "source line" })),
-	function: Type.Optional(Type.String({ description: "function name" })),
-	name: Type.Optional(Type.String({ description: "variable or data name" })),
-	condition: Type.Optional(Type.String({ description: "breakpoint condition" })),
-	hit_condition: Type.Optional(Type.String()),
-	expression: Type.Optional(Type.String({ description: "expression to evaluate" })),
-	context: Type.Optional(
-		Type.String({ description: "evaluate context: watch | repl | hover | variables | clipboard" }),
-	),
-	frame_id: Type.Optional(Type.Number()),
-	scope_id: Type.Optional(Type.Number({ description: "scope variables reference" })),
-	variable_ref: Type.Optional(Type.Number({ description: "variable reference" })),
-	pid: Type.Optional(Type.Number({ description: "process id for attach" })),
-	port: Type.Optional(Type.Number({ description: "remote attach port" })),
-	host: Type.Optional(Type.String({ description: "remote attach host" })),
-	levels: Type.Optional(Type.Number({ description: "max stack frames" })),
-	memory_reference: Type.Optional(Type.String({ description: "memory reference or address" })),
-	instruction_reference: Type.Optional(Type.String()),
-	instruction_count: Type.Optional(Type.Number()),
-	instruction_offset: Type.Optional(Type.Number()),
-	count: Type.Optional(Type.Number({ description: "bytes to read" })),
-	data: Type.Optional(Type.String({ description: "base64 memory payload" })),
-	data_id: Type.Optional(Type.String({ description: "data breakpoint id" })),
-	access_type: Type.Optional(StringEnum(["read", "write", "readWrite"])),
-	command: Type.Optional(Type.String({ description: "custom dap request command" })),
-	arguments: Type.Optional(Type.Record(Type.String(), Type.Any(), { description: "custom request arguments" })),
-	offset: Type.Optional(Type.Number()),
-	resolve_symbols: Type.Optional(Type.Boolean()),
-	allow_partial: Type.Optional(Type.Boolean()),
-	start_module: Type.Optional(Type.Number()),
-	module_count: Type.Optional(Type.Number()),
-	timeout: Type.Optional(Type.Number({ description: "per-request timeout seconds" })),
+	] as const),
+	program: z.string().describe("program path").optional(),
+	args: z.array(z.string()).describe("program arguments").optional(),
+	adapter: z.string().describe("debugger adapter (gdb, lldb-dap, debugpy, dlv)").optional(),
+	cwd: z.string().optional(),
+	file: z.string().describe("source file").optional(),
+	line: z.number().describe("source line").optional(),
+	function: z.string().describe("function name").optional(),
+	name: z.string().describe("variable or data name").optional(),
+	condition: z.string().describe("breakpoint condition").optional(),
+	hit_condition: z.string().optional(),
+	expression: z.string().describe("expression to evaluate").optional(),
+	context: z.string().describe("evaluate context: watch | repl | hover | variables | clipboard").optional(),
+	frame_id: z.number().optional(),
+	scope_id: z.number().describe("scope variables reference").optional(),
+	variable_ref: z.number().describe("variable reference").optional(),
+	pid: z.number().describe("process id for attach").optional(),
+	port: z.number().describe("remote attach port").optional(),
+	host: z.string().describe("remote attach host").optional(),
+	levels: z.number().describe("max stack frames").optional(),
+	memory_reference: z.string().describe("memory reference or address").optional(),
+	instruction_reference: z.string().optional(),
+	instruction_count: z.number().optional(),
+	instruction_offset: z.number().optional(),
+	count: z.number().describe("bytes to read").optional(),
+	data: z.string().describe("base64 memory payload").optional(),
+	data_id: z.string().describe("data breakpoint id").optional(),
+	access_type: z.enum(["read", "write", "readWrite"] as const).optional(),
+	command: z.string().describe("custom dap request command").optional(),
+	arguments: z.record(z.string(), z.any()).describe("custom request arguments").optional(),
+	offset: z.number().optional(),
+	resolve_symbols: z.boolean().optional(),
+	allow_partial: z.boolean().optional(),
+	start_module: z.number().optional(),
+	module_count: z.number().optional(),
+	timeout: z.number().describe("per-request timeout seconds").optional(),
 });
 
-export type DebugParams = Static<typeof debugSchema>;
+export type DebugParams = z.infer<typeof debugSchema>;
 export type DebugAction = DebugParams["action"];
 
 interface DebugToolDetails {

package/src/tools/eval.ts

@@ -3,7 +3,7 @@ import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Markdown, Text } from "@oh-my-pi/pi-tui";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { jsBackend, parseEvalInput, pythonBackend, sniffEvalLanguage } from "../eval";
 import type { ExecutorBackend } from "../eval/backend";
 import evalGrammar from "../eval/eval.lark" with { type: "text" };
@@ -16,7 +16,12 @@ import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
 import { getTreeBranch, getTreeContinuePrefix, renderCodeCell } from "../tui";
 import { resolveEvalBackends, type ToolSession } from ".";
-import { formatStyledTruncationWarning, resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "./output-meta";
+import {
+	formatStyledTruncationWarning,
+	resolveOutputMaxColumns,
+	resolveOutputSinkHeadBytes,
+	stripOutputNotice,
+} from "./output-meta";
 import { formatTitle, replaceTabs, shortenPath, truncateToWidth, wrapBrackets } from "./render-utils";
 import { ToolAbortError, ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
@@ -24,12 +29,10 @@ import { clampTimeout } from "./tool-timeouts";
 
 export const EVAL_DEFAULT_PREVIEW_LINES = 10;
 
-export const evalSchema = Type.Object({
-	input: Type.String({
-		description: 'eval input as a sequence of `*** Cell <lang>:"title"` cell headers followed by code',
-	}),
+export const evalSchema = z.object({
+	input: z.string().describe('eval input as a sequence of `*** Cell <lang>:"title"` cell headers followed by code'),
 });
-export type EvalToolParams = Static<typeof evalSchema>;
+export type EvalToolParams = z.infer<typeof evalSchema>;
 
 export type EvalToolResult = {
 	content: Array<{ type: "text"; text: string }>;
@@ -223,7 +226,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 	readonly parameters = evalSchema;
 	readonly concurrency = "exclusive";
 	readonly strict = true;
-	readonly intent = (args: Partial<Static<typeof evalSchema>>): string | undefined => {
+	readonly intent = (args: Partial<z.infer<typeof evalSchema>>): string | undefined => {
 		const input = args.input;
 		if (input) {
 			try {
@@ -249,7 +252,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof evalSchema>,
+		params: z.infer<typeof evalSchema>,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback,
 		_ctx?: AgentToolContext,
@@ -922,8 +925,11 @@ export const evalToolRenderer = {
 	): Component {
 		const details = result.details;
 
-		const output =
+		const rawOutput =
 			options.renderContext?.output ?? (result.content?.find(c => c.type === "text")?.text ?? "").trimEnd();
+		// Strip the LLM-facing notice (appended by wrappedExecute) before display;
+		// the styled `warningLine` below carries the same text in ⟨…⟩ form.
+		const output = stripOutputNotice(rawOutput, details?.meta).trimEnd();
 
 		const jsonOutputs = details?.jsonOutputs ?? [];
 		const jsonLines = jsonOutputs.flatMap((value, index) => {

package/src/tools/find.ts

@@ -5,8 +5,7 @@ import * as natives from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import type { Static } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
@@ -35,17 +34,15 @@ import {
 import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const findSchema = Type.Object({
-	paths: Type.Array(Type.String({ description: "glob including search path" }), {
-		minItems: 1,
-		description: "globs including search paths",
-		examples: [["src/**/*.ts"], ["lib/*.json"], ["apps/", "packages/"], ["*.ts"]],
-	}),
-	hidden: Type.Optional(Type.Boolean({ description: "include hidden files", default: true })),
-	limit: Type.Optional(Type.Number({ description: "max results", default: 1000 })),
-});
+const findSchema = z
+	.object({
+		paths: z.array(z.string().describe("glob including search path")).min(1).describe("globs including search paths"),
+		hidden: z.boolean().default(true).describe("include hidden files").optional(),
+		limit: z.number().default(1000).describe("max results").optional(),
+	})
+	.strict();
 
-export type FindToolInput = Static<typeof findSchema>;
+export type FindToolInput = z.infer<typeof findSchema>;
 
 const DEFAULT_LIMIT = 1000;
 const GLOB_TIMEOUT_MS = 5000;
@@ -107,7 +104,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof findSchema>,
+		params: z.infer<typeof findSchema>,
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		_context?: AgentToolContext,