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

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" };
@@ -29,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 }>;
@@ -228,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 {
@@ -254,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,

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,

package/src/tools/gh.ts

@@ -3,9 +3,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import { StringEnum } from "@oh-my-pi/pi-ai";
+
 import { getWorktreesDir, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import type { Settings } from "../config/settings";
 import githubDescription from "../prompts/tools/github.md" with { type: "text" };
 import * as git from "../utils/git";
@@ -197,135 +197,78 @@ const RUN_SUCCESS_CONCLUSIONS = new Set(["success", "neutral", "skipped"]);
 const RUN_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required", "startup_failure"]);
 const JOB_FAILURE_CONCLUSIONS = new Set(["failure", "timed_out", "cancelled", "action_required"]);
 
-const githubSchema = Type.Object({
-	op: StringEnum(
-		[
-			"repo_view",
-			"pr_create",
-			"pr_checkout",
-			"pr_push",
-			"search_issues",
-			"search_prs",
-			"search_code",
-			"search_commits",
-			"search_repos",
-			"run_watch",
-		],
-		{ description: "github operation" },
-	),
-	repo: Type.Optional(
-		Type.String({
-			description: "owner/repo (any op)",
-			examples: ["facebook/react"],
-		}),
-	),
-	branch: Type.Optional(
-		Type.String({
-			description: "branch (repo_view, pr_push local branch, run_watch)",
-			examples: ["main", "develop"],
-		}),
-	),
-	pr: Type.Optional(
-		Type.Union(
-			[
-				Type.String({ examples: ["123", "feature-branch"] }),
-				Type.Array(Type.String(), {
-					examples: [["123", "456"]],
-				}),
-			],
-			{
-				description:
-					"pr number, url, or branch (pr_checkout); pass an array to batch-process multiple pull requests in one call",
-			},
-		),
-	),
-	force: Type.Optional(Type.Boolean({ description: "reset existing local branch (pr_checkout)" })),
-	forceWithLease: Type.Optional(Type.Boolean({ description: "force-with-lease push (pr_push)" })),
-	title: Type.Optional(
-		Type.String({
-			description: "PR title (pr_create)",
-			examples: ["Fix login bug"],
-		}),
-	),
-	body: Type.Optional(
-		Type.String({
-			description: "PR body markdown (pr_create); mutually exclusive with fill",
-		}),
-	),
-	base: Type.Optional(
-		Type.String({
-			description: "PR base branch (pr_create); defaults to repo default branch",
-			examples: ["main"],
-		}),
-	),
-	head: Type.Optional(
-		Type.String({
-			description: "PR head branch (pr_create); defaults to current branch",
-			examples: ["feature/foo"],
-		}),
-	),
-	draft: Type.Optional(Type.Boolean({ description: "open PR as draft (pr_create)" })),
-	fill: Type.Optional(
-		Type.Boolean({
-			description: "auto-fill PR title/body from commits (pr_create); mutually exclusive with title/body",
-		}),
-	),
-	reviewer: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "reviewers to request (pr_create); accepts users or org/team",
-			examples: [["octocat", "myorg/team"]],
-		}),
-	),
-	assignee: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "assignees (pr_create); use @me for the authenticated user",
-			examples: [["@me"]],
-		}),
-	),
-	label: Type.Optional(
-		Type.Array(Type.String(), {
-			description: "labels to apply (pr_create)",
-			examples: [["bug", "enhancement"]],
-		}),
-	),
-	query: Type.Optional(
-		Type.String({
-			description: "search query (search_issues, search_prs, search_code, search_commits, search_repos)",
-			examples: ["is:open label:bug"],
-		}),
-	),
-	since: Type.Optional(
-		Type.String({
-			description:
+const githubSchema = z
+	.object({
+		op: z
+			.enum([
+				"repo_view",
+				"pr_create",
+				"pr_checkout",
+				"pr_push",
+				"search_issues",
+				"search_prs",
+				"search_code",
+				"search_commits",
+				"search_repos",
+				"run_watch",
+			] as const)
+			.describe("github operation"),
+		repo: z.string().describe("owner/repo (any op)").optional(),
+		branch: z.string().describe("branch (repo_view, pr_push local branch, run_watch)").optional(),
+		pr: z
+			.union([z.string(), z.array(z.string())])
+			.describe(
+				"pr number, url, or branch (pr_checkout); pass an array to batch-process multiple pull requests in one call",
+			)
+			.optional(),
+		force: z.boolean().describe("reset existing local branch (pr_checkout)").optional(),
+		forceWithLease: z.boolean().describe("force-with-lease push (pr_push)").optional(),
+		title: z.string().describe("PR title (pr_create)").optional(),
+		body: z.string().describe("PR body markdown (pr_create); mutually exclusive with fill").optional(),
+		base: z.string().describe("PR base branch (pr_create); defaults to repo default branch").optional(),
+		head: z.string().describe("PR head branch (pr_create); defaults to current branch").optional(),
+		draft: z.boolean().describe("open PR as draft (pr_create)").optional(),
+		fill: z
+			.boolean()
+			.describe("auto-fill PR title/body from commits (pr_create); mutually exclusive with title/body")
+			.optional(),
+		reviewer: z.array(z.string()).describe("reviewers to request (pr_create); accepts users or org/team").optional(),
+		assignee: z.array(z.string()).describe("assignees (pr_create); use @me for the authenticated user").optional(),
+		label: z.array(z.string()).describe("labels to apply (pr_create)").optional(),
+		query: z
+			.string()
+			.describe("search query (search_issues, search_prs, search_code, search_commits, search_repos)")
+			.optional(),
+		since: z
+			.string()
+			.describe(
 				"lower-bound date for search_issues/search_prs/search_commits/search_repos. Accepts a relative duration (`<n><unit>` with unit `m`/`h`/`d`/`w`/`mo`/`y`, e.g. `3d`, `12h`, `2w`) or an ISO date (`YYYY-MM-DD`) / datetime. Translated to a `created:>=…` (or `committer-date:`/`pushed:`) qualifier; not supported by search_code.",
-			examples: ["3d", "2w", "2026-05-01"],
-		}),
-	),
-	until: Type.Optional(
-		Type.String({
-			description:
+			)
+			.optional(),
+		until: z
+			.string()
+			.describe(
 				"upper-bound date in the same format as `since`. With both, builds a `field:since..until` range qualifier.",
-			examples: ["1d", "2026-05-09"],
-		}),
-	),
-	dateField: Type.Optional(
-		StringEnum(["created", "updated"], {
-			description:
+			)
+			.optional(),
+		dateField: z
+			.enum(["created", "updated"] as const)
+			.describe(
 				"date field used by `since`/`until`. issues/prs: `created` (default) or `updated`. repos: `created` (default) or `updated` (mapped to GitHub's `pushed:`). commits: ignored — always uses `committer-date`.",
-			default: "created",
-		}),
-	),
-	limit: Type.Optional(
-		Type.Number({
-			description: "max results (search_issues, search_prs, search_code, search_commits, search_repos)",
-			default: 10,
-		}),
-	),
-	run: Type.Optional(Type.String({ description: "actions run id or url (run_watch)", examples: ["123456"] })),
-	tail: Type.Optional(Type.Number({ description: "log lines per failed job (run_watch)", default: 15 })),
-});
-
-type GithubInput = Static<typeof githubSchema>;
+			)
+			.default("created")
+			.optional(),
+		limit: z
+			.number()
+			.default(10)
+			.describe("max results (search_issues, search_prs, search_code, search_commits, search_repos)")
+			.optional(),
+		run: z.string().describe("actions run id or url (run_watch)").optional(),
+		tail: z.number().default(15).describe("log lines per failed job (run_watch)").optional(),
+	})
+	.strict();
+
+type GithubInput = z.infer<typeof githubSchema>;
 
 export interface GhToolDetails {
 	meta?: OutputMeta;

package/src/tools/hindsight-recall.ts

@@ -1,17 +1,15 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { formatCurrentTime, formatMemories } from "../hindsight/content";
 import recallDescription from "../prompts/tools/recall.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const hindsightRecallSchema = Type.Object({
-	query: Type.String({
-		description: "Natural language search query. Be specific about what you need to know.",
-	}),
+const hindsightRecallSchema = z.object({
+	query: z.string().describe("Natural language search query. Be specific about what you need to know."),
 });
 
-export type HindsightRecallParams = Static<typeof hindsightRecallSchema>;
+export type HindsightRecallParams = z.infer<typeof hindsightRecallSchema>;
 
 export class HindsightRecallTool implements AgentTool<typeof hindsightRecallSchema> {
 	readonly name = "recall";

package/src/tools/hindsight-reflect.ts

@@ -1,16 +1,16 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
 import { logger, untilAborted } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { ensureBankMission } from "../hindsight/bank";
 import reflectDescription from "../prompts/tools/reflect.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const hindsightReflectSchema = Type.Object({
-	query: Type.String({ description: "The question to answer using long-term memory." }),
-	context: Type.Optional(Type.String({ description: "Optional additional context to guide the reflection." })),
+const hindsightReflectSchema = z.object({
+	query: z.string().describe("The question to answer using long-term memory."),
+	context: z.string().describe("Optional additional context to guide the reflection.").optional(),
 });
 
-export type HindsightReflectParams = Static<typeof hindsightReflectSchema>;
+export type HindsightReflectParams = z.infer<typeof hindsightReflectSchema>;
 
 export class HindsightReflectTool implements AgentTool<typeof hindsightReflectSchema> {
 	readonly name = "reflect";

package/src/tools/hindsight-retain.ts

@@ -1,27 +1,25 @@
 import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import retainDescription from "../prompts/tools/retain.md" with { type: "text" };
 import type { ToolSession } from ".";
 
-const hindsightRetainSchema = Type.Object({
-	items: Type.Array(
-		Type.Object({
-			content: Type.String({
-				description: "The information to remember. Be specific and self-contained — include who, what, when, why.",
+const hindsightRetainSchema = z.object({
+	items: z
+		.array(
+			z.object({
+				content: z
+					.string()
+					.describe("The information to remember. Be specific and self-contained — include who, what, when, why."),
+				context: z.string().describe("Optional context describing where this information came from.").optional(),
 			}),
-			context: Type.Optional(
-				Type.String({ description: "Optional context describing where this information came from." }),
-			),
-		}),
-		{
-			minItems: 1,
-			description:
-				"One or more memories to retain. Batch related facts in a single call rather than calling retain repeatedly — they are deduplicated and consolidated together.",
-		},
-	),
+		)
+		.min(1)
+		.describe(
+			"One or more memories to retain. Batch related facts in a single call rather than calling retain repeatedly — they are deduplicated and consolidated together.",
+		),
 });
 
-export type HindsightRetainParams = Static<typeof hindsightRetainSchema>;
+export type HindsightRetainParams = z.infer<typeof hindsightRetainSchema>;
 export class HindsightRetainTool implements AgentTool<typeof hindsightRetainSchema> {
 	readonly name = "retain";
 	readonly label = "Retain";

package/src/tools/image-gen.ts

@@ -1,6 +1,6 @@
 import * as os from "node:os";
 import * as path from "node:path";
-import { getAntigravityUserAgent, getEnvApiKey, type Model, StringEnum } from "@oh-my-pi/pi-ai";
+import { getAntigravityUserAgent, getEnvApiKey, type Model } from "@oh-my-pi/pi-ai";
 import {
 	CODEX_BASE_URL,
 	getCodexAccountId,
@@ -18,7 +18,7 @@ import {
 	Snowflake,
 	untilAborted,
 } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import packageJson from "../../package.json" with { type: "json" };
 import { isAuthenticated, type ModelRegistry } from "../config/model-registry";
 import type { CustomTool } from "../extensibility/custom-tools/types";
@@ -46,87 +46,37 @@ interface ImageApiKey {
 	model?: Model;
 }
 
-const responseModalitySchema = StringEnum(["IMAGE", "TEXT"]);
-const aspectRatioSchema = StringEnum(["1:1", "3:4", "4:3", "9:16", "16:9"], {
-	description: "aspect ratio",
-	examples: ["1:1", "3:4", "16:9"],
-});
-const imageSizeSchema = StringEnum(["1024x1024", "1536x1024", "1024x1536"], {
-	description: "image size",
-	examples: ["1024x1024", "1536x1024"],
-});
-
-const inputImageSchema = Type.Object(
-	{
-		path: Type.Optional(Type.String({ description: "input image path" })),
-		data: Type.Optional(Type.String({ description: "base64 image data" })),
-		mime_type: Type.Optional(Type.String({ description: "mime type" })),
-	},
-	{ additionalProperties: false },
-);
-
-const baseImageSchema = Type.Object(
-	{
-		subject: Type.String({
-			description: "main subject",
-			examples: ["a stoic robot barista", "a weathered lighthouse"],
-		}),
-		action: Type.Optional(
-			Type.String({
-				description: "what subject is doing",
-				examples: ["pouring latte art", "standing against waves"],
-			}),
-		),
-		scene: Type.Optional(
-			Type.String({
-				description: "location or environment",
-				examples: ["futuristic café on mars", "thunderstorm at dusk"],
-			}),
-		),
-		composition: Type.Optional(
-			Type.String({
-				description: "camera angle and framing",
-				examples: ["low-angle close-up", "wide establishing shot"],
-			}),
-		),
-		lighting: Type.Optional(
-			Type.String({
-				description: "lighting setup",
-				examples: ["warm rim lighting", "golden hour backlight"],
-			}),
-		),
-		style: Type.Optional(
-			Type.String({
-				description: "artistic style",
-				examples: ["film noir", "studio ghibli watercolor", "photorealistic"],
-			}),
-		),
-		text: Type.Optional(
-			Type.String({
-				description: "text to render",
-				examples: ["headline 'urban explorer' top center"],
-			}),
-		),
-		changes: Type.Optional(
-			Type.Array(Type.String(), {
-				description: "edits to make",
-				examples: [["change tie to green", "remove car"]],
-			}),
-		),
-		aspect_ratio: Type.Optional(aspectRatioSchema),
-		image_size: Type.Optional(imageSizeSchema),
-		input: Type.Optional(
-			Type.Array(inputImageSchema, {
-				description: "input images",
-			}),
-		),
-	},
-	{ additionalProperties: false },
-);
+const responseModalitySchema = z.enum(["IMAGE", "TEXT"] as const);
+const aspectRatioSchema = z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"] as const).describe("aspect ratio");
+const imageSizeSchema = z.enum(["1024x1024", "1536x1024", "1024x1536"] as const).describe("image size");
+
+const inputImageSchema = z
+	.object({
+		path: z.string().describe("input image path").optional(),
+		data: z.string().describe("base64 image data").optional(),
+		mime_type: z.string().describe("mime type").optional(),
+	})
+	.strict();
+
+const baseImageSchema = z
+	.object({
+		subject: z.string().describe("main subject"),
+		action: z.string().describe("what subject is doing").optional(),
+		scene: z.string().describe("location or environment").optional(),
+		composition: z.string().describe("camera angle and framing").optional(),
+		lighting: z.string().describe("lighting setup").optional(),
+		style: z.string().describe("artistic style").optional(),
+		text: z.string().describe("text to render").optional(),
+		changes: z.array(z.string()).describe("edits to make").optional(),
+		aspect_ratio: aspectRatioSchema.optional(),
+		image_size: imageSizeSchema.optional(),
+		input: z.array(inputImageSchema).describe("input images").optional(),
+	})
+	.strict();
 
 export const imageGenSchema = baseImageSchema;
-export type ImageGenParams = Static<typeof imageGenSchema>;
-export type GeminiResponseModality = Static<typeof responseModalitySchema>;
+export type ImageGenParams = z.infer<typeof imageGenSchema>;
+export type GeminiResponseModality = z.infer<typeof responseModalitySchema>;
 
 /**
  * Assembles a structured prompt from the provided parameters.

package/src/tools/index.ts

@@ -1,4 +1,4 @@
-import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
 import { $env, $flag, logger } from "@oh-my-pi/pi-utils";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -250,6 +250,9 @@ export interface ToolSession {
 
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
+	/** Get the active OpenTelemetry config so subagent dispatch can forward
+	 *  the parent's tracer/hooks with the subagent's own identity stamped. */
+	getTelemetry?: () => AgentTelemetryConfig | undefined;
 }
 
 export type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;

package/src/tools/inspect-image.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Api, completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { type Static, Type } from "@sinclair/typebox";
+import * as z from "zod/v4";
 import { extractTextContent } from "../commit/utils";
 import { expandRoleAlias, resolveModelFromString } from "../config/model-resolver";
 import inspectImageDescription from "../prompts/tools/inspect-image.md" with { type: "text" };
@@ -15,15 +15,14 @@ import {
 import type { ToolSession } from "./index";
 import { ToolError } from "./tool-errors";
 
-const inspectImageSchema = Type.Object(
-	{
-		path: Type.String({ description: "image path", examples: ["image.png"] }),
-		question: Type.String({ description: "question about image", examples: ["What is in this image?"] }),
-	},
-	{ additionalProperties: false },
-);
+const inspectImageSchema = z
+	.object({
+		path: z.string().describe("image path"),
+		question: z.string().describe("question about image"),
+	})
+	.strict();
 
-export type InspectImageParams = Static<typeof inspectImageSchema>;
+export type InspectImageParams = z.infer<typeof inspectImageSchema>;
 
 export interface InspectImageToolDetails {
 	model: string;

package/src/tools/irc.ts

@@ -20,39 +20,27 @@
 
 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 ircDescription from "../prompts/tools/irc.md" with { type: "text" };
 import type { AgentRef, AgentRegistry } from "../registry/agent-registry";
 import type { ToolSession } from ".";
 
-const ircSchema = Type.Object({
-	op: Type.Union(
-		[
-			Type.Literal("send", { description: "Send a message to one peer or to all peers" }),
-			Type.Literal("list", { description: "List currently visible peers" }),
-		],
-		{ description: "IRC operation" },
-	),
-	to: Type.Optional(
-		Type.String({
-			description: 'Recipient agent id (e.g. "0-Main", "0-AuthLoader") or "all" to broadcast',
-			examples: ["0-Main", "all"],
-		}),
-	),
-	message: Type.Optional(
-		Type.String({
-			description: "Message body to deliver",
-			examples: ["Should we use JWT or session cookies?"],
-		}),
-	),
-	awaitReply: Type.Optional(
-		Type.Boolean({
-			description: "Wait for the recipient's prose reply (default: true for DM, false for broadcast)",
-		}),
-	),
+const ircSchema = z.object({
+	op: z
+		.union([
+			z.literal("send").describe("Send a message to one peer or to all peers"),
+			z.literal("list").describe("List currently visible peers"),
+		])
+		.describe("IRC operation"),
+	to: z.string().optional().describe('Recipient agent id (e.g. "0-Main", "0-AuthLoader") or "all" to broadcast'),
+	message: z.string().optional().describe("Message body to deliver"),
+	awaitReply: z
+		.boolean()
+		.optional()
+		.describe("Wait for the recipient's prose reply (default: true for DM, false for broadcast)"),
 });
 
-type IrcParams = Static<typeof ircSchema>;
+type IrcParams = z.infer<typeof ircSchema>;
 
 interface IrcReply {
 	from: string;