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

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;
@@ -1774,6 +1717,39 @@ export async function resolveDefaultRepoMemoized(cwd: string, signal?: AbortSign
 	return untilAborted(signal, pending);
 }
 
+/**
+ * Matches search-query qualifiers that already scope to a repository, org, or
+ * user. When present, callers should avoid layering a default `repo:<current>`
+ * on top — the user has already expressed an explicit scope.
+ *
+ * Only the leading `repo:`/`org:`/`user:`/`owner:` token is treated as a
+ * scope marker; arbitrary substrings (e.g. inside quoted text) are ignored.
+ */
+const REPO_SCOPE_QUALIFIER_PATTERN = /(?:^|\s)-?(?:repo|org|user|owner):\S/i;
+
+/**
+ * Resolve the effective `repo:` scope for a search op. Returns the explicit
+ * `repo` when set, `undefined` when the query already carries a scoping
+ * qualifier, and otherwise the current checkout's `owner/repo` via
+ * `resolveDefaultRepoMemoized`. Resolution failures (no git/gh context, no
+ * configured remote) silently fall back to `undefined` so the search proceeds
+ * across all of GitHub instead of throwing.
+ */
+async function resolveSearchRepoScope(
+	cwd: string,
+	repo: string | undefined,
+	query: string | undefined,
+	signal: AbortSignal | undefined,
+): Promise<string | undefined> {
+	if (repo) return repo;
+	if (query && REPO_SCOPE_QUALIFIER_PATTERN.test(query)) return undefined;
+	try {
+		return await resolveDefaultRepoMemoized(cwd, signal);
+	} catch {
+		return undefined;
+	}
+}
+
 async function resolveGitHubBranchHead(
 	cwd: string,
 	repo: string,
@@ -3267,11 +3243,11 @@ async function executeSearchIssues(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
 	const dateField = resolveSearchDateField("issues", params.dateField);
 	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
 	const displayQuery = composeSearchQuery([params.query, dateQualifier]);
+	const repo = await resolveSearchRepoScope(session.cwd, normalizeOptionalString(params.repo), displayQuery, signal);
 	const apiQuery = composeSearchQuery([displayQuery, repo ? `repo:${repo}` : undefined, "is:issue"]);
 	const args = buildGhApiSearchArgs("issues", apiQuery, limit);
 
@@ -3285,11 +3261,11 @@ async function executeSearchPrs(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
 	const dateField = resolveSearchDateField("prs", params.dateField);
 	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
 	const displayQuery = composeSearchQuery([params.query, dateQualifier]);
+	const repo = await resolveSearchRepoScope(session.cwd, normalizeOptionalString(params.repo), displayQuery, signal);
 	const apiQuery = composeSearchQuery([displayQuery, repo ? `repo:${repo}` : undefined, "is:pr"]);
 	const args = buildGhApiSearchArgs("issues", apiQuery, limit);
 
@@ -3307,8 +3283,8 @@ async function executeSearchCode(
 	if (params.since !== undefined || params.until !== undefined) {
 		throw new ToolError("search_code does not support since/until; GitHub code search has no date qualifier.");
 	}
-	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
+	const repo = await resolveSearchRepoScope(session.cwd, normalizeOptionalString(params.repo), query, signal);
 	const apiQuery = composeSearchQuery([query, repo ? `repo:${repo}` : undefined]);
 	const args = buildGhApiSearchArgs("code", apiQuery, limit, ["Accept: application/vnd.github.text-match+json"]);
 
@@ -3322,11 +3298,11 @@ async function executeSearchCommits(
 	params: GithubInput,
 	signal: AbortSignal | undefined,
 ): Promise<AgentToolResult<GhToolDetails>> {
-	const repo = normalizeOptionalString(params.repo);
 	const limit = resolveSearchLimit(params.limit);
 	const dateField = resolveSearchDateField("commits", params.dateField);
 	const dateQualifier = buildSearchDateQualifier(dateField, params.since, params.until);
 	const displayQuery = composeSearchQuery([params.query, dateQualifier]);
+	const repo = await resolveSearchRepoScope(session.cwd, normalizeOptionalString(params.repo), displayQuery, signal);
 	const apiQuery = composeSearchQuery([displayQuery, repo ? `repo:${repo}` : undefined]);
 	const args = buildGhApiSearchArgs("commits", apiQuery, limit);
 

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;