@oh-my-pi/pi-coding-agent 15.0.2 → 15.1.1

package/src/task/types.ts

@@ -1,7 +1,7 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
-import { type Static, type TSchema, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { getTaskSimpleModeCapabilities, type TaskSimpleMode } from "./simple-mode";
 import type { NestedRepoPatch } from "./worktree";
 
@@ -63,65 +63,65 @@ const assignmentDescriptionForContextDisabled =
 	"Complete per-task instructions the subagent executes. Must follow the Target/Change/Edge Cases/Acceptance structure, and include any background that would otherwise live in `context` since shared context is disabled in this mode.";
 
 const createTaskItemSchema = (contextEnabled: boolean) =>
-	Type.Object({
-		id: Type.String({
-			description: "CamelCase identifier, max 48 chars",
-			maxLength: 48,
-		}),
-		description: Type.String({
-			description: "Short one-liner for UI display only — not seen by the subagent",
-		}),
-		assignment: Type.String({
-			description: contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled,
-		}),
+	z.object({
+		id: z.string().max(48).describe("CamelCase identifier, max 48 chars"),
+		description: z.string().describe("Short one-liner for UI display only — not seen by the subagent"),
+		assignment: z
+			.string()
+			.describe(contextEnabled ? assignmentDescriptionForContextEnabled : assignmentDescriptionForContextDisabled),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
 export const taskItemSchema = createTaskItemSchema(true);
-export type TaskItem = Static<typeof taskItemSchema>;
+export type TaskItem = z.infer<typeof taskItemSchema>;
 
 const createTaskSchema = (options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }) => {
 	const { contextEnabled, customSchemaEnabled } = getTaskSimpleModeCapabilities(options.simpleMode);
 	const itemSchema = createTaskItemSchema(contextEnabled);
-	const properties: Record<string, TSchema> = {
-		agent: Type.String({ description: "Agent type for all tasks in this batch" }),
-		tasks: Type.Array(itemSchema, {
-			description: contextEnabled
-				? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
-				: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
-		}),
-	};
+
+	let schema = z.object({
+		agent: z.string().describe("Agent type for all tasks in this batch"),
+		tasks: z
+			.array(itemSchema)
+			.describe(
+				contextEnabled
+					? "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and self-contained given context + assignment."
+					: "Tasks to execute in parallel. Each must be small-scoped (3-5 files max) and fully self-contained inside assignment because shared context is disabled.",
+			),
+	});
 
 	if (contextEnabled) {
-		properties.context = Type.Optional(
-			Type.String({
-				description:
+		schema = schema.extend({
+			context: z
+				.string()
+				.optional()
+				.describe(
 					"Shared background prepended to every task's assignment. Put goal, non-goals, constraints, conventions, reference paths, API contracts, and global acceptance commands here once — instead of duplicating across assignments.",
-			}),
-		);
+				),
+		});
 	}
 
 	if (customSchemaEnabled) {
-		properties.schema = Type.Optional(
-			Type.String({
-				description:
+		schema = schema.extend({
+			schema: z
+				.string()
+				.optional()
+				.describe(
 					"JSON-encoded JTD schema defining expected response structure. Output format belongs here — never in context or assignment.",
-			}),
-		);
+				),
+		});
 	}
 
 	if (options.isolationEnabled) {
-		return Type.Object({
-			...properties,
-			isolated: Type.Optional(
-				Type.Boolean({
-					description: "Run in isolated environment; returns patches. Use when tasks edit overlapping files.",
-				}),
-			),
+		schema = schema.extend({
+			isolated: z
+				.boolean()
+				.optional()
+				.describe("Run in isolated environment; returns patches. Use when tasks edit overlapping files."),
 		});
 	}
 
-	return Type.Object(properties);
+	return schema;
 };
 
 export const taskSchema = createTaskSchema({ isolationEnabled: true, simpleMode: "default" });
@@ -141,6 +141,8 @@ const ALL_TASK_SCHEMAS = [
 
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
+/** Active task tool parameter schema for the current simple-mode / isolation flags */
+export type TaskToolSchemaInstance = DynamicTaskSchema;
 
 export function getTaskSchema(options: { isolationEnabled: boolean; simpleMode: TaskSimpleMode }): DynamicTaskSchema {
 	switch (options.simpleMode) {
@@ -219,6 +221,15 @@ export interface AgentProgress {
 	toolCount: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/**
+	 * Current per-turn context size: latest assistant message's `usage.totalTokens`.
+	 * This is the number to compare against `contextWindow` — what compaction
+	 * decides on, what the user typically reads as "how full is the context".
+	 * Distinct from `tokens`, which is a lifetime billing-volume counter.
+	 */
+	contextTokens?: number;
+	/** Model's context window in tokens, when known. Lets the UI render `<curr>/<window>` gauges. */
+	contextWindow?: number;
 	/** Cumulative billing cost in USD, accumulated incrementally from message_end events. */
 	cost: number;
 	durationMs: number;
@@ -244,6 +255,10 @@ export interface SingleResult {
 	durationMs: number;
 	/** Cumulative input + output + cacheWrite tokens across all turns. Excludes cacheRead (re-reads cached context every turn, making cumulative sum misleading). */
 	tokens: number;
+	/** Latest per-turn context size at task completion. See `AgentProgress.contextTokens`. */
+	contextTokens?: number;
+	/** Model's context window in tokens, when known. */
+	contextWindow?: number;
 	modelOverride?: string | string[];
 	error?: string;
 	aborted?: boolean;

package/src/tools/ask.ts

@@ -18,7 +18,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component, Container, Markdown, renderInlineMarkdown, TERMINAL, 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 { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -31,23 +31,23 @@ import { ToolAbortError } from "./tool-errors";
 // Types
 // =============================================================================
 
-const OptionItem = Type.Object({
-	label: Type.String({ description: "display label" }),
+const OptionItem = z.object({
+	label: z.string().describe("display label"),
 });
 
-const QuestionItem = Type.Object({
-	id: Type.String({ description: "question id", examples: ["auth", "cache"] }),
-	question: Type.String({ description: "question text" }),
-	options: Type.Array(OptionItem, { description: "available options" }),
-	multi: Type.Optional(Type.Boolean({ description: "allow multiple selections" })),
-	recommended: Type.Optional(Type.Number({ description: "recommended option index" })),
+const QuestionItem = z.object({
+	id: z.string().describe("question id"),
+	question: z.string().describe("question text"),
+	options: z.array(OptionItem).describe("available options"),
+	multi: z.boolean().describe("allow multiple selections").optional(),
+	recommended: z.number().describe("recommended option index").optional(),
 });
 
-const askSchema = Type.Object({
-	questions: Type.Array(QuestionItem, { description: "questions to ask", minItems: 1 }),
+const askSchema = z.object({
+	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
 });
 
-export type AskToolInput = Static<typeof askSchema>;
+export type AskToolInput = z.infer<typeof askSchema>;
 
 /** Result for a single question */
 export interface QuestionResult {

package/src/tools/ast-edit.ts

@@ -4,7 +4,7 @@ import { type AstReplaceChange, type AstReplaceFileChange, astEdit } from "@oh-m
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { $envpos, 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 { computeLineHash, HL_BODY_SEP } from "../hashline/hash";
 import type { Theme } from "../modes/theme/theme";
@@ -33,21 +33,17 @@ import { queueResolveHandler } from "./resolve";
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astEditOpSchema = Type.Object({
-	pat: Type.String({ description: "ast pattern", examples: ["oldFn($$$ARGS)"] }),
-	out: Type.String({ description: "replacement template", examples: ["newFn($$$ARGS)"] }),
+const astEditOpSchema = z.object({
+	pat: z.string().describe("ast pattern"),
+	out: z.string().describe("replacement template"),
 });
 
-const astEditSchema = Type.Object({
-	ops: Type.Array(astEditOpSchema, {
-		minItems: 1,
-		description: "rewrite ops",
-	}),
-	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to rewrite" }), {
-		minItems: 1,
-		description: "files, directories, globs, or internal URLs to rewrite",
-		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
-	}),
+const astEditSchema = z.object({
+	ops: z.array(astEditOpSchema).min(1).describe("rewrite ops"),
+	paths: z
+		.array(z.string().describe("file, directory, glob, or internal URL to rewrite"))
+		.min(1)
+		.describe("files, directories, globs, or internal URLs to rewrite"),
 });
 
 interface AstEditCallOptions {
@@ -174,7 +170,7 @@ export class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolD
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof astEditSchema>,
+		params: z.infer<typeof astEditSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>,
 		_context?: AgentToolContext,

package/src/tools/ast-grep.ts

@@ -4,7 +4,7 @@ import { type AstFindMatch, astGrep } from "@oh-my-pi/pi-natives";
 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 astGrepDescription from "../prompts/tools/ast-grep.md" with { type: "text" };
@@ -32,14 +32,13 @@ import {
 import { ToolError } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
-const astGrepSchema = Type.Object({
-	pat: Type.String({ description: "ast pattern", examples: ["console.log($$$)"] }),
-	paths: Type.Array(Type.String({ description: "file, directory, glob, or internal URL to search" }), {
-		minItems: 1,
-		description: "files, directories, globs, or internal URLs to search",
-		examples: [["src/"], ["src/foo.ts"], ["src/**/*.ts"], ["src/", "packages/"]],
-	}),
-	skip: Type.Optional(Type.Number({ description: "matches to skip", default: 0 })),
+const astGrepSchema = z.object({
+	pat: z.string().describe("ast pattern"),
+	paths: z
+		.array(z.string().describe("file, directory, glob, or internal URL to search"))
+		.min(1)
+		.describe("files, directories, globs, or internal URLs to search"),
+	skip: z.number().default(0).describe("matches to skip").optional(),
 });
 
 async function runMultiTargetAstGrep(
@@ -129,7 +128,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 	async execute(
 		_toolCallId: string,
-		params: Static<typeof astGrepSchema>,
+		params: z.infer<typeof astGrepSchema>,
 		signal?: AbortSignal,
 		_onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>,
 		_context?: AgentToolContext,

package/src/tools/bash.ts

@@ -3,7 +3,7 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { $env, getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
-import { Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { AsyncJobManager } from "../async";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -44,30 +44,16 @@ async function saveBashOriginalArtifact(session: ToolSession, originalText: stri
 	}
 }
 
-const bashSchemaBase = Type.Object({
-	command: Type.String({ description: "command to execute", examples: ["ls -la", "echo hi"] }),
-	env: Type.Optional(
-		Type.Record(Type.String({ pattern: BASH_ENV_NAME_PATTERN.source }), Type.String(), {
-			description: "extra env vars",
-		}),
-	),
-	timeout: Type.Optional(Type.Number({ description: "timeout in seconds", default: 300 })),
-	cwd: Type.Optional(Type.String({ description: "working directory", examples: ["src/", "/tmp"] })),
-
-	pty: Type.Optional(
-		Type.Boolean({
-			description: "run in pty mode",
-		}),
-	),
+const bashSchemaBase = z.object({
+	command: z.string().describe("command to execute"),
+	env: z.record(z.string().regex(BASH_ENV_NAME_PATTERN), z.string()).optional().describe("extra env vars"),
+	timeout: z.number().default(300).describe("timeout in seconds").optional(),
+	cwd: z.string().describe("working directory").optional(),
+	pty: z.boolean().describe("run in pty mode").optional(),
 });
 
-const bashSchemaWithAsync = Type.Object({
-	...bashSchemaBase.properties,
-	async: Type.Optional(
-		Type.Boolean({
-			description: "run in background",
-		}),
-	),
+const bashSchemaWithAsync = bashSchemaBase.extend({
+	async: z.boolean().describe("run in background").optional(),
 });
 
 type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;

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 {