@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

package/src/cli-commands.ts

@@ -39,6 +39,7 @@ export const commands: CommandEntry[] = [
 	{ name: "usage", load: () => import("./commands/usage").then(m => m.default) },
 	{ name: "tiny-models", load: () => import("./commands/tiny-models").then(m => m.default) },
 	{ name: "token", load: () => import("./commands/token").then(m => m.default) },
+	{ name: "ttsr", load: () => import("./commands/ttsr").then(m => m.default) },
 	{ name: "worktree", load: () => import("./commands/worktree").then(m => m.default), aliases: ["wt"] },
 	{ name: "search", load: () => import("./commands/web-search").then(m => m.default), aliases: ["q"] },
 ];

package/src/cli.ts

@@ -275,7 +275,13 @@ export async function runCli(argv: string[]): Promise<void> {
 	// Declare this module as the worker-host entry now that the active profile
 	// is resolved. The worker-host module is side-effect-free; importing
 	// `@oh-my-pi/pi-utils/env` here would snapshot the wrong agent `.env`.
-	declareWorkerHostEntry();
+	// Gated on `import.meta.main`: only the real CLI process entry is a valid
+	// worker host. Worker-thread re-entry already returned above at the
+	// `__omp_worker_` dispatch, and importers (`runCli` in profile-CLI tests,
+	// SDK embedding) have `import.meta.main === false` — declaring there would
+	// poison `workerHostEntry()` for the whole test process, forcing eval/stats/
+	// browser workers onto the same-realm inline fallback.
+	if (import.meta.main) declareWorkerHostEntry();
 
 	if (resolvedArgv[0] === "--smoke-test") {
 		await runSmokeTest();

package/src/collab/host.ts

@@ -415,7 +415,7 @@ export class CollabHost {
 		// render exactly the same anchored, provider-real count the host's own
 		// status line shows.
 		const breakdown = this.#ctx.statusLine.getCachedContextBreakdown();
-		const tokens = breakdown.usedTokens;
+		const tokens = breakdown.usedTokens ?? 0;
 		return {
 			isStreaming: session.isStreaming,
 			isAborting: session.isAborting,
@@ -427,7 +427,7 @@ export class CollabHost {
 			contextUsage: {
 				tokens,
 				contextWindow: breakdown.contextWindow,
-				percent: tokens !== null && breakdown.contextWindow > 0 ? (tokens / breakdown.contextWindow) * 100 : null,
+				percent: breakdown.contextWindow > 0 ? (tokens / breakdown.contextWindow) * 100 : 0,
 			},
 			participants: this.participants,
 		};

package/src/commands/launch.ts

@@ -136,6 +136,9 @@ export default class Index extends Command {
 		"no-title": Flags.boolean({
 			description: "Disable title auto-generation",
 		}),
+		"max-time": Flags.string({
+			description: "Stop the session after this many seconds",
+		}),
 		// `--auto-approve` / `--yolo`: declared here so oclif's auto-generated `--help` lists it.
 		// Runtime parsing happens in `cli/args.ts parseArgs` (line 176 in that file) — `runRootCommand`
 		// consumes the manual-parser output, not these oclif flag values. If you rename or remove

package/src/commands/ttsr.ts

@@ -0,0 +1,125 @@
+import { existsSync } from "node:fs";
+import * as path from "node:path";
+/**
+ * `omp ttsr` — inspect and test Time-Traveling Stream Rules.
+ *
+ * `omp ttsr test` feeds a snippet (inline, --file, or stdin) through the real
+ * TTSR matching pipeline and reports which rules would trigger. `omp ttsr list`
+ * shows every TTSR-registered rule the current project/user config would load.
+ */
+import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import {
+	runTtsrCommand,
+	TTSR_ACTIONS,
+	TTSR_SOURCES,
+	type TtsrCommandArgs,
+	type TtsrScanArgs,
+	type TtsrTestArgs,
+} from "../cli/ttsr-cli";
+import type { TtsrMatchSource } from "../export/ttsr";
+
+export default class Ttsr extends Command {
+	static description = "Inspect and test Time-Traveling Stream Rules (TTSR)";
+
+	static args = {
+		action: Args.string({
+			description: "TTSR action",
+			required: false,
+			options: TTSR_ACTIONS,
+		}),
+		snippet: Args.string({
+			description: "Inline snippet text to test (ttsr test) or directory to scan (ttsr scan)",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		file: Flags.string({ description: "Snippet file path, or - for stdin (ttsr test)" }),
+		rule: Flags.string({
+			char: "r",
+			description: "Rule markdown file to test in isolation (skips project rule loading)",
+		}),
+		source: Flags.string({
+			description: "Match source: text, thinking, or tool (inferred from --file when omitted)",
+			options: TTSR_SOURCES,
+		}),
+		tool: Flags.string({
+			description: "Tool name when source is tool (e.g. edit, write); defaults to edit",
+		}),
+		path: Flags.string({
+			char: "p",
+			description: "Candidate file path for scope/glob matching and AST language inference",
+		}),
+		verbose: Flags.boolean({ char: "v", description: "Show every evaluated rule, not just triggered ones" }),
+		json: Flags.boolean({ description: "Output JSON" }),
+		"no-gitignore": Flags.boolean({ description: "Include files excluded by .gitignore (ttsr scan)" }),
+		"max-bytes": Flags.integer({
+			description: "Maximum file size to scan in bytes; 0 disables the limit (ttsr scan)",
+		}),
+	};
+
+	static examples = [
+		"omp ttsr list",
+		"omp ttsr test 'const x: any = 1'",
+		"omp ttsr test src/foo.ts",
+		"omp ttsr test --file src/foo.ts",
+		"omp ttsr test --file src/foo.ts --source text",
+		"omp ttsr test --rule .omp/rules/no-any.md --source tool --path src/foo.ts 'const x: any = 1'",
+		"echo 'Box::leak(&mut v)' | omp ttsr test --file - --path src/lib.rs",
+		"omp ttsr test --source tool --tool edit --path src/foo.ts 'const x: any = 1'",
+		"omp ttsr scan",
+		"omp ttsr scan src/",
+		"omp ttsr scan -r .omp/rules/no-any.md src/",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Ttsr);
+		const action = (args.action ?? "list") as (typeof TTSR_ACTIONS)[number];
+
+		// A positional that resolves to an existing file is a snippet file, not
+		// inline text — so `omp ttsr test src/foo.ts` works without --file.
+		// --file always wins over the positional.
+		let file = flags.file;
+		let snippet = args.snippet;
+		if (action === "test" && snippet && !file) {
+			const resolved = path.resolve(snippet);
+			if (existsSync(resolved)) {
+				file = resolved;
+				snippet = undefined;
+			}
+		}
+
+		const test: TtsrTestArgs | undefined =
+			action === "test"
+				? {
+						snippet,
+						file,
+						rule: flags.rule,
+						source: flags.source as TtsrMatchSource | undefined,
+						tool: flags.tool,
+						filePath: flags.path,
+						verbose: flags.verbose,
+					}
+				: undefined;
+
+		const scan: TtsrScanArgs | undefined =
+			action === "scan"
+				? {
+						directory: args.snippet,
+						rule: flags.rule,
+						gitignore: !flags["no-gitignore"],
+						maxBytes: flags["max-bytes"],
+						verbose: flags.verbose,
+					}
+				: undefined;
+
+		const cmd: TtsrCommandArgs = {
+			action,
+			test,
+			scan,
+			json: flags.json,
+		};
+
+		await runTtsrCommand(cmd);
+	}
+}

package/src/commit/agentic/tools/analyze-file.ts

@@ -1,5 +1,5 @@
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import analyzeFilePrompt from "../../../commit/agentic/prompts/analyze-file.md" with { type: "text" };
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { NumstatEntry } from "../../../commit/types";
@@ -12,9 +12,9 @@ import type { TaskParams } from "../../../task/types";
 import type { ToolSession } from "../../../tools";
 import { getFilePriority } from "./git-file-diff";
 
-const analyzeFileSchema = z.object({
-	files: z.array(z.string().describe("file path")).min(1),
-	goal: z.string().describe("analysis focus").optional(),
+const analyzeFileSchema = type({
+	files: type("string").describe("file path").array().atLeastLength(1),
+	"goal?": type("string").describe("analysis focus"),
 });
 
 const analyzeFileOutputSchema = {

package/src/commit/agentic/tools/git-file-diff.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
@@ -131,9 +131,9 @@ function processDiffs(files: string[], diffs: Map<string, string>): { result: st
 	return { result: parts.join("\n\n"), truncatedFiles };
 }
 
-const gitFileDiffSchema = z.object({
-	files: z.array(z.string().describe("file to diff")).min(1).max(10),
-	staged: z.boolean().describe("use staged changes (default true)").optional(),
+const gitFileDiffSchema = type({
+	files: type("string").describe("file to diff").array().atLeastLength(1).atMostLength(10),
+	"staged?": type("boolean").describe("use staged changes (default true)"),
 });
 
 export function createGitFileDiffTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitFileDiffSchema> {

package/src/commit/agentic/tools/git-hunk.ts

@@ -1,12 +1,14 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { DiffHunk, FileHunks } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 
-const gitHunkSchema = z.object({
-	file: z.string().describe("file path"),
-	hunks: z.array(z.number().describe("1-based hunk index")).min(1).optional(),
-	staged: z.boolean().describe("use staged changes (default true)").optional(),
+const hunkIndexType = type("number").describe("1-based hunk index");
+
+const gitHunkSchema = type({
+	file: type("string").describe("file path"),
+	"hunks?": hunkIndexType.array().atLeastLength(1),
+	"staged?": type("boolean").describe("use staged changes (default true)"),
 });
 
 function selectHunks(fileHunks: FileHunks, requested?: number[]): DiffHunk[] {

package/src/commit/agentic/tools/git-overview.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CommitAgentState, GitOverviewSnapshot } from "../../../commit/agentic/state";
 import { extractScopeCandidates } from "../../../commit/analysis/scope";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
@@ -42,9 +42,9 @@ function filterExcludedFiles(files: string[]): { filtered: string[]; excluded: s
 	return { filtered, excluded };
 }
 
-const gitOverviewSchema = z.object({
-	staged: z.boolean().describe("use staged changes (default true)").optional(),
-	include_untracked: z.boolean().describe("include untracked when unstaged").optional(),
+const gitOverviewSchema = type({
+	"staged?": type("boolean").describe("use staged changes (default true)"),
+	"include_untracked?": type("boolean").describe("include untracked when unstaged"),
 });
 
 export function createGitOverviewTool(cwd: string, state: CommitAgentState): CustomTool<typeof gitOverviewSchema> {

package/src/commit/agentic/tools/propose-changelog.ts

@@ -1,27 +1,30 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import { CHANGELOG_CATEGORIES, type ChangelogCategory } from "../../../commit/types";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 
-const changelogEntryProperties = CHANGELOG_CATEGORIES.reduce<Record<ChangelogCategory, z.ZodType>>(
-	(acc, category) => {
-		acc[category] = z.array(z.string()).optional();
-		return acc;
-	},
-	{} as Record<ChangelogCategory, z.ZodType>,
-);
+const changelogCategoryProperties = {
+	"Breaking Changes?": "string[]",
+	"Added?": "string[]",
+	"Changed?": "string[]",
+	"Deprecated?": "string[]",
+	"Removed?": "string[]",
+	"Fixed?": "string[]",
+	"Security?": "string[]",
+} as const;
 
-const changelogEntriesSchema = z.object(changelogEntryProperties);
-const changelogDeletionsSchema = z.object(changelogEntryProperties).describe("entries to remove");
+const changelogEntriesSchema = type({
+	...changelogCategoryProperties,
+});
 
-const changelogEntrySchema = z.object({
-	path: z.string(),
+const changelogEntrySchema = type({
+	path: "string",
 	entries: changelogEntriesSchema,
-	deletions: changelogDeletionsSchema.optional(),
+	"deletions?": changelogEntriesSchema.describe("entries to remove"),
 });
 
-const proposeChangelogSchema = z.object({
-	entries: z.array(changelogEntrySchema),
+const proposeChangelogSchema = type({
+	entries: changelogEntrySchema.array(),
 });
 
 interface ChangelogResponse {

package/src/commit/agentic/tools/propose-commit.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CommitAgentState } from "../../../commit/agentic/state";
 import {
 	capDetails,
@@ -15,12 +15,12 @@ import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
-const proposeCommitSchema = z.object({
+const proposeCommitSchema = type({
 	type: commitTypeSchema,
-	scope: z.union([z.string(), z.null()]),
-	summary: z.string(),
-	details: z.array(detailSchema),
-	issue_refs: z.array(z.string()),
+	scope: type("string").or("null"),
+	summary: "string",
+	details: detailSchema.array(),
+	issue_refs: "string[]",
 });
 
 interface ProposalResponse {

package/src/commit/agentic/tools/recent-commits.ts

@@ -1,9 +1,9 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 
-const recentCommitsSchema = z.object({
-	count: z.number().min(1).max(50).describe("commit count").optional(),
+const recentCommitsSchema = type({
+	"count?": type("1 <= number <= 50").describe("commit count"),
 });
 
 interface RecentCommitStats {

package/src/commit/agentic/tools/schemas.ts

@@ -1,23 +1,11 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 
-export const commitTypeSchema = z.enum([
-	"feat",
-	"fix",
-	"refactor",
-	"perf",
-	"docs",
-	"test",
-	"build",
-	"ci",
-	"chore",
-	"style",
-	"revert",
-] as const);
+export const commitTypeSchema = type(
+	"'feat' | 'fix' | 'refactor' | 'perf' | 'docs' | 'test' | 'build' | 'ci' | 'chore' | 'style' | 'revert'",
+);
 
-export const detailSchema = z.object({
-	text: z.string(),
-	changelog_category: z
-		.enum(["Added", "Changed", "Fixed", "Deprecated", "Removed", "Security", "Breaking Changes"])
-		.optional(),
-	user_visible: z.boolean().optional(),
+export const detailSchema = type({
+	text: "string",
+	"changelog_category?": "'Added' | 'Changed' | 'Fixed' | 'Deprecated' | 'Removed' | 'Security' | 'Breaking Changes'",
+	"user_visible?": "boolean",
 });

package/src/commit/agentic/tools/split-commit.ts

@@ -1,4 +1,4 @@
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { CommitAgentState, SplitCommitGroup, SplitCommitPlan } from "../../../commit/agentic/state";
 import { computeDependencyOrder } from "../../../commit/agentic/topo-sort";
 import {
@@ -15,32 +15,28 @@ import type { CustomTool } from "../../../extensibility/custom-tools/types";
 import * as git from "../../../utils/git";
 import { commitTypeSchema, detailSchema } from "./schemas.js";
 
-const hunkSelectorSchema = z.discriminatedUnion("type", [
-	z.object({ type: z.literal("all") }),
-	z.object({ type: z.literal("indices"), indices: z.array(z.number()).min(1) }),
-	z.object({ type: z.literal("lines"), start: z.number(), end: z.number() }),
-]);
+const hunkSelectorSchema = type({ type: "'all'" })
+	.or({ type: "'indices'", indices: "number[]" })
+	.or({ type: "'lines'", start: "number", end: "number" });
 
-const fileChangeSchema = z.object({
-	path: z.string(),
+const fileChangeSchema = type({
+	path: "string",
 	hunks: hunkSelectorSchema,
 });
 
-const splitCommitSchema = z.object({
-	commits: z
-		.array(
-			z.object({
-				changes: z.array(fileChangeSchema).min(1),
-				type: commitTypeSchema,
-				scope: z.union([z.string(), z.null()]),
-				summary: z.string(),
-				details: z.array(detailSchema).optional(),
-				issue_refs: z.array(z.string()).optional(),
-				rationale: z.string().optional(),
-				dependencies: z.array(z.number()).optional(),
-			}),
-		)
-		.min(2),
+const commitItemSchema = type({
+	changes: fileChangeSchema.array(),
+	type: commitTypeSchema,
+	scope: type("string").or("null"),
+	summary: "string",
+	"details?": detailSchema.array(),
+	"issue_refs?": "string[]",
+	"rationale?": "string",
+	"dependencies?": "number[]",
+});
+
+const splitCommitSchema = type({
+	commits: commitItemSchema.array(),
 });
 
 interface SplitCommitResponse {

package/src/commit/analysis/summary.ts

@@ -2,19 +2,21 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKey, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import summarySystemPrompt from "../../commit/prompts/summary-system.md" with { type: "text" };
 import summaryUserPrompt from "../../commit/prompts/summary-user.md" with { type: "text" };
 import type { CommitSummary } from "../../commit/types";
 import { toReasoningEffort } from "../../thinking";
 import { extractTextContent, extractToolCall } from "../utils";
 
+const SummaryToolSchema = type({
+	summary: "string",
+});
+
 const SummaryTool = {
 	name: "create_commit_summary",
 	description: "Generate the summary line for a conventional commit message.",
-	parameters: z.object({
-		summary: z.string(),
-	}),
+	parameters: SummaryToolSchema,
 };
 
 export interface SummaryInput {
@@ -83,7 +85,7 @@ function renderSummaryPrompt({
 function parseSummaryFromResponse(message: AssistantMessage, commitType: string, scope: string | null): CommitSummary {
 	const toolCall = extractToolCall(message, "create_commit_summary");
 	if (toolCall) {
-		const parsed = validateToolCall([SummaryTool], toolCall) as z.infer<(typeof SummaryTool)["parameters"]>;
+		const parsed = validateToolCall([SummaryTool], toolCall) as (typeof SummaryToolSchema)["infer"];
 		return { summary: stripTypePrefix(parsed.summary, commitType, scope) };
 	}
 	const text = extractTextContent(message);

package/src/commit/changelog/generate.ts

@@ -2,25 +2,29 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKey, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { completeSimple, validateToolCall } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import changelogSystemPrompt from "../../commit/prompts/changelog-system.md" with { type: "text" };
 import changelogUserPrompt from "../../commit/prompts/changelog-user.md" with { type: "text" };
-import { CHANGELOG_CATEGORIES, type ChangelogCategory, type ChangelogGenerationResult } from "../../commit/types";
+import type { ChangelogGenerationResult } from "../../commit/types";
 import { toReasoningEffort } from "../../thinking";
 import { extractTextContent, extractToolCall, parseJsonPayload } from "../utils";
 
-const changelogEntryShape = Object.fromEntries(
-	CHANGELOG_CATEGORIES.map(c => [c, z.array(z.string()).optional()] as const),
-) as Record<ChangelogCategory, z.ZodOptional<z.ZodArray<z.ZodString>>>;
-
-const changelogEntriesSchema = z.object(changelogEntryShape);
+// Build the changelog entry schema with arktype
+// Each category maps to an optional array of strings
+const changelogEntriesSchema = type({
+	"Breaking Changes?": "string[]",
+	"Added?": "string[]",
+	"Changed?": "string[]",
+	"Deprecated?": "string[]",
+	"Removed?": "string[]",
+	"Fixed?": "string[]",
+	"Security?": "string[]",
+});
 
 export const changelogTool = {
 	name: "create_changelog_entries",
 	description: "Generate changelog entries grouped by Keep a Changelog categories.",
-	parameters: z.object({
-		entries: changelogEntriesSchema,
-	}),
+	parameters: type({ entries: changelogEntriesSchema }),
 };
 
 export interface ChangelogPromptInput {
@@ -68,7 +72,7 @@ export async function generateChangelogEntries({
 function parseChangelogResponse(message: AssistantMessage): ChangelogGenerationResult {
 	const toolCall = extractToolCall(message, "create_changelog_entries");
 	if (toolCall) {
-		const parsed = validateToolCall([changelogTool], toolCall) as z.infer<(typeof changelogTool)["parameters"]>;
+		const parsed = validateToolCall([changelogTool], toolCall) as typeof changelogTool.parameters.infer;
 		return { entries: parsed.entries ?? {} };
 	}
 

package/src/commit/shared-llm.ts

@@ -1,36 +1,29 @@
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import { validateToolCall } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
+import { type as t, validateToolCall } from "@oh-my-pi/pi-ai";
 import type { ChangelogCategory, ConventionalAnalysis } from "./types";
 import { extractTextContent, extractToolCall, normalizeAnalysis, parseJsonPayload } from "./utils";
 
-const changelogCategoryLiteral = z.enum([
-	"Added",
-	"Changed",
-	"Fixed",
-	"Deprecated",
-	"Removed",
-	"Security",
-	"Breaking Changes",
-]);
+const changelogCategoryLiteral = t(
+	"'Added' | 'Changed' | 'Fixed' | 'Deprecated' | 'Removed' | 'Security' | 'Breaking Changes'",
+);
 
 /**
- * Shared Zod schema for the `create_conventional_analysis` tool used by
+ * Shared arktype schema for the `create_conventional_analysis` tool used by
  * both the single-pass analysis call and the map-reduce reduce phase. Schemas
  * are identical across phases — only the surrounding tool `description`
  * differs to reflect the input the phase is summarizing.
  */
-export const conventionalAnalysisParameters = z.object({
-	type: z.enum(["feat", "fix", "refactor", "docs", "test", "chore", "style", "perf", "build", "ci", "revert"]),
-	scope: z.union([z.string(), z.null()]),
-	details: z.array(
-		z.object({
-			text: z.string(),
-			changelog_category: changelogCategoryLiteral.optional(),
-			user_visible: z.boolean().optional(),
-		}),
-	),
-	issue_refs: z.array(z.string()),
+const detailItem = t({
+	text: "string",
+	"changelog_category?": changelogCategoryLiteral,
+	"user_visible?": "boolean",
+});
+
+export const conventionalAnalysisParameters = t({
+	type: "'feat' | 'fix' | 'refactor' | 'docs' | 'test' | 'chore' | 'style' | 'perf' | 'build' | 'ci' | 'revert'",
+	scope: t("string").or("null"),
+	details: detailItem.array(),
+	issue_refs: "string[]",
 });
 
 export interface ConventionalAnalysisTool {
@@ -68,7 +61,7 @@ export function parseConventionalAnalysisResponse(
 ): ConventionalAnalysis {
 	const toolCall = extractToolCall(message, tool.name);
 	if (toolCall) {
-		const parsed = validateToolCall([tool], toolCall) as z.infer<typeof conventionalAnalysisParameters>;
+		const parsed = validateToolCall([tool], toolCall) as any;
 		return normalizeAnalysis(parsed);
 	}
 	const text = extractTextContent(message);