@oh-my-pi/pi-ai 17.2.9 → 17.2.10

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [17.2.10] - 2026-08-06
+
+### Breaking Changes
+
+- Removed the `zod` dependency and `z`/`ZodType` re-exports. Tool schemas now use `omptype` `type()` schemas, with Zod-style authoring still available via `@oh-my-pi/omptype/zod`.
+
 ## [17.2.9] - 2026-08-05
 
 ### Fixed

package/README.md

@@ -94,21 +94,18 @@ npm install @oh-my-pi/pi-ai
 ## Quick Start
 
 ```typescript
-import { z, getModel, stream, complete, Context, Tool } from "@oh-my-pi/pi-ai";
+import { getModel, stream, complete, Context, Tool, type } from "@oh-my-pi/pi-ai";
 
 // Fully typed with auto-complete support for both providers and models
 const model = getModel("openai", "gpt-4o-mini");
 
-// Define tools with Zod schemas for type safety and validation
+// Define tools with omptype schemas for type safety and validation
 const tools: Tool[] = [
 	{
 		name: "get_time",
 		description: "Get the current time",
-		parameters: z.object({
-			timezone: z
-				.string()
-				.optional()
-				.describe("Optional timezone (e.g., America/New_York)"),
+		parameters: type({
+			"timezone?": type("string").describe("Optional timezone (e.g., America/New_York)"),
 		}),
 	},
 ];
@@ -221,31 +218,30 @@ for (const block of response.content) {
 
 ## Tools
 
-Tools enable LLMs to interact with external systems. This library uses **Zod** schemas for type-safe tool definitions with automatic validation. Schemas are converted to JSON Schema for providers as needed.
+Tools enable LLMs to interact with external systems. Omptype schemas provide type-safe definitions, runtime validation, and JSON Schema conversion for providers.
 
 ### Defining Tools
 
 ```typescript
-import { z, Tool } from "@oh-my-pi/pi-ai";
+import { type Tool, type } from "@oh-my-pi/pi-ai";
 
-// Define tool parameters with Zod
 const weatherTool: Tool = {
 	name: "get_weather",
 	description: "Get current weather for a location",
-	parameters: z.object({
-		location: z.string().describe("City name or coordinates"),
-		units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+	parameters: type({
+		location: type("string").describe("City name or coordinates"),
+		units: type.enumerated("celsius", "fahrenheit").default("celsius"),
 	}),
 };
 
 const bookMeetingTool: Tool = {
 	name: "book_meeting",
 	description: "Schedule a meeting",
-	parameters: z.object({
-		title: z.string().min(1),
-		startTime: z.string().describe("ISO 8601 date-time"),
-		endTime: z.string().describe("ISO 8601 date-time"),
-		attendees: z.array(z.email()).min(1),
+	parameters: type({
+		title: type("string").atLeastLength(1),
+		startTime: type("string").describe("ISO 8601 date-time"),
+		endTime: type("string").describe("ISO 8601 date-time"),
+		attendees: type("string.email").array().atLeastLength(1),
 	}),
 };
 ```
@@ -345,7 +341,7 @@ for await (const event of s) {
 
 ### Validating Tool Arguments
 
-When using `agentLoop`, tool arguments are automatically validated against your Zod parameter schemas before execution. If validation fails, the error is returned to the model as a tool result, allowing it to retry.
+When using `agentLoop`, tool arguments are automatically validated against their omptype schemas before execution. Validation failures are returned to the model as tool results so it can retry.
 
 When implementing your own tool execution loop with `stream()` or `complete()`, use `validateToolCall` to validate arguments before passing them to your tools:
 

package/dist/types/index.d.ts

@@ -1,5 +1,4 @@
 export { type Type, type } from "@oh-my-pi/omptype";
-export { type ZodType, z } from "zod/v4";
 export * from "./api-registry.js";
 export type * from "./auth-broker/index.js";
 export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/server.js";

package/dist/types/types.d.ts

@@ -4,7 +4,6 @@ import type { Type } from "@oh-my-pi/omptype";
 import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, GrepArgs, GrepResult, LsArgs, LsResult, McpResult, PiBashExecArgs, PiBashExecResult, PiEditExecArgs, PiEditExecResult, PiFindExecArgs, PiFindExecResult, PiGrepExecArgs, PiGrepExecResult, PiLsExecArgs, PiLsExecResult, PiReadExecArgs, PiReadExecResult, PiWriteExecArgs, PiWriteExecResult, ReadArgs, ReadResult, ShellArgs, ShellResult, WriteArgs, WriteResult } from "@oh-my-pi/pi-catalog/discovery/cursor-gen/agent_pb";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { Api, FetchImpl, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";
-import type { ZodType, z } from "zod/v4";
 import type { ApiKey } from "./auth-retry.js";
 import type { BedrockOptions } from "./providers/amazon-bedrock.js";
 import type { AnthropicOptions } from "./providers/anthropic.js";
@@ -928,12 +927,12 @@ export type TJsonSchema = Record<string, unknown>;
 /**
  * Schema type accepted by the {@link Tool} interface.
  *
- * Canonical authoring uses Zod or ArkType. Extension compat may supply a JSON
- * Schema object (including TypeBox static schema objects).
+ * Canonical authoring uses ArkType. Extension compat may supply a JSON Schema
+ * object (including TypeBox static schema objects).
  */
-export type TSchema = ZodType | Type | TJsonSchema;
+export type TSchema = Type | TJsonSchema;
 /** Resolve parameter types for tool execution / handlers. */
-export type Static<S> = S extends ZodType ? z.infer<S> : S extends Type ? S["infer"] : S extends {
+export type Static<S> = S extends Type ? S["infer"] : S extends {
     static: infer T;
 } ? T : unknown;
 export interface ToolCallExample<TArgs = Record<string, unknown>> {

package/dist/types/utils/schema/index.d.ts

@@ -12,4 +12,3 @@ export * from "./strict-tool-validation.js";
 export * from "./types.js";
 export * from "./typescript.js";
 export * from "./wire.js";
-export * from "./zod-decontaminate.js";

package/dist/types/utils/schema/wire.d.ts

@@ -1,76 +1,36 @@
 /**
  * Compute the wire (JSON Schema) representation of a tool's parameters.
  *
- * Tools may author parameters in three shapes:
- *   1. Zod (canonical) — converted to JSON Schema on demand.
- *   2. ArkType — converted to JSON Schema via its native `toJsonSchema`.
- *   3. TypeBox / plain JSON Schema (legacy + extension compat) — upgraded to
- *      draft 2020-12 without converting.
- *
- * All three are normalized at the boundary so providers and validators see the same
- * JSON Schema dialect.
+ * Tools may author parameters as ArkType schemas or legacy TypeBox / plain JSON
+ * Schema documents. Both are normalized at the boundary so providers and
+ * validators see the same JSON Schema dialect.
  */
 import type { Type } from "@oh-my-pi/omptype";
-import { type ZodType } from "zod/v4";
 import type { Tool } from "../../types.js";
-/**
- * True when `value` is a live Zod schema instance.
- *
- * The check is stricter than "has a `_zod` property" because a JSON
- * round-trip preserves the `_zod` key as a plain object and would otherwise
- * fool the predicate — see issue #1101, where MCP servers ship
- * `JSON.stringify(zodSchemaInstance)` as a tool's `inputSchema` and the
- * resulting plain object then explodes `z.toJSONSchema` because the prototype
- * (and every Zod parsing method) is gone.
- *
- * Live Zod instances always carry a `.parse` function on the prototype;
- * impostors do not.
- */
-export declare function isZodSchema(value: unknown): value is ZodType;
 /**
  * True when `value` is a live ArkType schema instance.
  *
  * ArkType schemas are callable functions carrying `toJsonSchema`/`assert`
- * methods. Zod v4 instances are non-callable objects (keyed off `_zod`), and
- * raw JSON Schema is a plain object — the three are disjoint. We deliberately
- * avoid the Standard Schema `~standard` marker because Zod v4 implements it too.
+ * methods, while raw JSON Schema is a plain object.
  */
 export declare function isArkSchema(value: unknown): value is Type;
 /**
- * Normalize `{}` (empty JSON Schema = `z.unknown()` / unconstrained value) to
- * boolean `true` in every schema-valued position. JSON Schema draft 2020-12
- * §4.3.1: `{}` and `true` are semantically equivalent ("any JSON value").
- * Grammar-constrained samplers (llama.cpp, etc.) treat the object form as
- * "generate an empty object" rather than "any JSON value", causing open-typed
- * fields like `extra.title` (from `z.record(z.string(), z.unknown())`) to
- * always emit `{}` instead of the intended string/number/etc. (issue #1179).
+ * Normalize `{}` (an unconstrained schema) to boolean `true` in every
+ * schema-valued position. JSON Schema draft 2020-12 §4.3.1 defines them as
+ * semantically equivalent. Grammar-constrained samplers often treat the object
+ * form as "generate an empty object" rather than "any JSON value".
  *
- * Mutates in place. Provider-agnostic — applied to every tool wire schema so
- * Anthropic, Google, OpenAI, Ollama, Bedrock, and Cursor all see the
- * normalized form, regardless of whether the source was Zod or TypeBox.
+ * Mutates in place and applies to every tool wire schema.
  */
 export declare function normalizeEmptySchemas(node: unknown): void;
-/** Convert a Zod schema into the JSON Schema shape providers consume. */
-export declare function zodToWireSchema(schema: ZodType): Record<string, unknown>;
 /**
  * Convert an ArkType schema into the JSON Schema shape providers consume.
- *
- * Mirrors {@link zodToWireSchema}: emit draft-2020-12, drop the `$schema`
- * metadata, run the JSON-schema post-process (NOT the Zod-only cleanup), then
- * close declared objects so the wire is `additionalProperties: false` like Zod.
- *
- * The `fallback` degrades any un-emittable node (a `.narrow()` predicate or a
- * morph) to its underlying base schema instead of throwing — matching Zod,
- * whose `.refine()`/`.transform()` likewise never appear in the wire schema.
  */
 export declare function arkToWireSchema(schema: Type): Record<string, unknown>;
 /**
  * Resolve a tool's parameters to a JSON Schema object suitable for sending
- * over the wire. Zod schemas are converted (and cached); legacy TypeBox / raw
- * JSON Schema parameters are upgraded to draft 2020-12 (and cached).
- *
- * Zod schemas also receive Zod-artifact cleanup; both branches normalize
- * schema-valued positions and nullable scalar unions.
+ * over the wire. ArkType schemas are converted and cached; legacy TypeBox /
+ * raw JSON Schema parameters are upgraded to draft 2020-12 and cached.
  */
 export declare function toolWireSchema(tool: Tool): Record<string, unknown>;
 /**

package/dist/types/utils/validation.d.ts

@@ -1,22 +1,10 @@
 /**
  * Tool-call argument validation pipeline.
  *
- * Tools may declare their parameters as either Zod schemas (canonical) or
- * plain JSON Schema (legacy / extensions). This module is the single
- * entrypoint the agent calls before dispatching a tool — it:
- *
- *   1. Builds (or fetches from cache) a `ValidationContext` for the tool —
- *      the Zod schema if available plus the equivalent wire JSON Schema, or
- *      just the JSON Schema for non-Zod tools.
- *   2. Normalizes LLM quirks (null / "null" → omit-or-default substitution)
- *      against the JSON Schema before validation.
- *   3. Validates with the Zod or JSON-Schema validator.
- *   4. On failure, walks the resulting issues and coerces common LLM type
- *      drift (JSON-stringified values, boolean/number/string scalar drift),
- *      drops unrecognized keys, and retries up to `MAX_COERCION_PASSES` times.
- *   5. Throws a formatted error if reconciliation fails; otherwise returns
- *      the parsed arguments with original unknown root fields preserved (so
- *      hallucinated top-level keys still surface to the caller).
+ * Tools may declare ArkType schemas or plain JSON Schema. This module builds a
+ * cached validation context, normalizes common LLM quirks against the wire
+ * schema, validates, performs conservative schema-directed coercions, and
+ * returns parsed arguments while preserving unknown root fields.
  *
  * The goal is to be conservative: every coercion is a structural rewrite that
  * keeps the schema in charge of acceptance — we never invent values, only
@@ -32,10 +20,8 @@ import type { Tool, ToolCall } from "../types.js";
  */
 export declare function validateToolCall(tools: Tool[], toolCall: ToolCall): ToolCall["arguments"];
 /**
- * Validates tool call arguments against the tool's schema (Zod or plain JSON
- * Schema). Applies LLM-quirk coercions (numeric strings, JSON-string
- * containers, null/invalid-empty-string-for-optional, null-for-default) before
- * declaring failure.
+ * Validates tool call arguments against an ArkType or plain JSON Schema schema.
+ * Applies conservative LLM-quirk normalization before declaring failure.
  *
  * @throws Error with a formatted message when validation cannot be reconciled.
  */

package/dist/types/utils.d.ts

@@ -17,6 +17,15 @@ interface OpenAIResponsesReplaySanitizeOptions {
     supportsImageDetailOriginal?: boolean;
     supportsComputerUse?: boolean;
 }
+/**
+ * Removes response-only lifecycle status from item types that reject it when replayed as input.
+ *
+ * Returns the original array when no item needs sanitization.
+ */
+export declare function stripOpenAIResponsesOutputOnlyStatusesForReplay<TItem extends {
+    type?: unknown;
+    status?: unknown;
+}>(items: TItem[]): TItem[];
 export declare function sanitizeOpenAIResponsesHistoryItemsForReplay(items: Array<Record<string, unknown>>, options?: OpenAIResponsesReplaySanitizeOptions): ResponseInput;
 /** Strip reasoning IDs whose only linked native output is a computer call that will be demoted. */
 export declare function stripOpenAIResponsesComputerLinkedReasoningIdsForReplay(items: ResponseInput): ResponseInput;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "17.2.9",
+	"version": "17.2.10",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,11 +38,10 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.1",
-		"@oh-my-pi/omptype": "17.2.9",
-		"@oh-my-pi/pi-catalog": "17.2.9",
-		"@oh-my-pi/pi-utils": "17.2.9",
-		"@oh-my-pi/pi-wire": "17.2.9",
-		"zod": "^4"
+		"@oh-my-pi/omptype": "17.2.10",
+		"@oh-my-pi/pi-catalog": "17.2.10",
+		"@oh-my-pi/pi-utils": "17.2.10",
+		"@oh-my-pi/pi-wire": "17.2.10"
 	},
 	"devDependencies": {
 		"@bufbuild/protoc-gen-es": "^2.12.1",

package/src/index.ts

@@ -1,5 +1,4 @@
 export { type Type, type } from "@oh-my-pi/omptype";
-export { type ZodType, z } from "zod/v4";
 export * from "./api-registry";
 export type * from "./auth-broker";
 export type { AuthGatewayBootOptions, ModelResolver } from "./auth-gateway/server";

package/src/types.ts

@@ -36,7 +36,6 @@ import type {
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { isOpenAIModelId } from "@oh-my-pi/pi-catalog/identity/family";
 import type { Api, FetchImpl, KnownApi, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";
-import type { ZodType, z } from "zod/v4";
 import type { ApiKey } from "./auth-retry";
 import type { BedrockOptions } from "./providers/amazon-bedrock";
 import type { AnthropicOptions } from "./providers/anthropic";
@@ -1140,19 +1139,13 @@ export type TJsonSchema = Record<string, unknown>;
 /**
  * Schema type accepted by the {@link Tool} interface.
  *
- * Canonical authoring uses Zod or ArkType. Extension compat may supply a JSON
- * Schema object (including TypeBox static schema objects).
+ * Canonical authoring uses ArkType. Extension compat may supply a JSON Schema
+ * object (including TypeBox static schema objects).
  */
-export type TSchema = ZodType | Type | TJsonSchema;
+export type TSchema = Type | TJsonSchema;
 
 /** Resolve parameter types for tool execution / handlers. */
-export type Static<S> = S extends ZodType
-	? z.infer<S>
-	: S extends Type
-		? S["infer"]
-		: S extends { static: infer T }
-			? T
-			: unknown;
+export type Static<S> = S extends Type ? S["infer"] : S extends { static: infer T } ? T : unknown;
 
 export interface ToolCallExample<TArgs = Record<string, unknown>> {
 	caption?: string;

package/src/utils/schema/index.ts

@@ -12,4 +12,3 @@ export * from "./strict-tool-validation";
 export * from "./types";
 export * from "./typescript";
 export * from "./wire";
-export * from "./zod-decontaminate";

package/src/utils/schema/normalize.ts

@@ -24,7 +24,6 @@ import { isValidJsonSchema } from "./meta-validator";
 import { type DescriptionSpillFormat, spillToDescription } from "./spill";
 import { enter, epochNext, exit, once, stamp } from "./stamps";
 import { isJsonObject, isJsonObjectEmpty, type JsonObject } from "./types";
-import { decontaminateZodInstance } from "./zod-decontaminate";
 
 export type ResidualSchemaIncompatibility = "type-array" | "type-null" | "nullable" | "combiners" | "not";
 
@@ -1069,8 +1068,7 @@ function hasResidualSchemaIncompatibilities(
 }
 
 export function normalizeSchema(value: unknown, options: NormalizeSchemaOptions): unknown {
-	const detoxified = decontaminateZodInstance(value);
-	const upgraded = upgradeJsonSchemaTo202012(detoxified);
+	const upgraded = upgradeJsonSchemaTo202012(value);
 	const dereferenced = dereferenceJsonSchema(upgraded);
 	let normalized = normalizeSchemaNode(dereferenced, {
 		...options,

package/src/utils/schema/wire.ts

@@ -1,62 +1,21 @@
 /**
  * Compute the wire (JSON Schema) representation of a tool's parameters.
  *
- * Tools may author parameters in three shapes:
- *   1. Zod (canonical) — converted to JSON Schema on demand.
- *   2. ArkType — converted to JSON Schema via its native `toJsonSchema`.
- *   3. TypeBox / plain JSON Schema (legacy + extension compat) — upgraded to
- *      draft 2020-12 without converting.
- *
- * All three are normalized at the boundary so providers and validators see the same
- * JSON Schema dialect.
+ * Tools may author parameters as ArkType schemas or legacy TypeBox / plain JSON
+ * Schema documents. Both are normalized at the boundary so providers and
+ * validators see the same JSON Schema dialect.
  */
 
 import type { Type } from "@oh-my-pi/omptype";
-// We import the Zod *value* (z) for runtime APIs. Marker checks rely on the
-// `_zod` symbol that every Zod v4 schema instance carries.
-import { type ZodType, z } from "zod/v4";
 import type { Tool, TSchema } from "../../types";
 import { upgradeJsonSchemaTo202012 } from "./draft";
 import { stamp } from "./stamps";
 
-/**
- * True when `value` is a live Zod schema instance.
- *
- * The check is stricter than "has a `_zod` property" because a JSON
- * round-trip preserves the `_zod` key as a plain object and would otherwise
- * fool the predicate — see issue #1101, where MCP servers ship
- * `JSON.stringify(zodSchemaInstance)` as a tool's `inputSchema` and the
- * resulting plain object then explodes `z.toJSONSchema` because the prototype
- * (and every Zod parsing method) is gone.
- *
- * Live Zod instances always carry a `.parse` function on the prototype;
- * impostors do not.
- */
-export function isZodSchema(value: unknown): value is ZodType {
-	return (
-		typeof value === "object" &&
-		value !== null &&
-		// Zod v4 instances expose a `_zod` internal property with a `def` object.
-		// Tagging on this marker keeps the check stable across Zod minor versions.
-		// (`_zod` is part of Zod's documented internal contract used by introspection.)
-		// We avoid checking constructor name because Zod ships multiple variants
-		// (`ZodObject`, `ZodOptional`, etc.) and a tagged-union style check would
-		// have to enumerate them all.
-		"_zod" in value &&
-		typeof (value as { _zod?: { def?: unknown } })._zod === "object" &&
-		// Reject JSON-roundtripped objects that kept the `_zod` key but lost the
-		// prototype. Real instances have `.parse` on the prototype chain.
-		typeof (value as { parse?: unknown }).parse === "function"
-	);
-}
-
 /**
  * True when `value` is a live ArkType schema instance.
  *
  * ArkType schemas are callable functions carrying `toJsonSchema`/`assert`
- * methods. Zod v4 instances are non-callable objects (keyed off `_zod`), and
- * raw JSON Schema is a plain object — the three are disjoint. We deliberately
- * avoid the Standard Schema `~standard` marker because Zod v4 implements it too.
+ * methods, while raw JSON Schema is a plain object.
  */
 export function isArkSchema(value: unknown): value is Type {
 	return (
@@ -149,41 +108,17 @@ function arkJsonAstToWire(value: unknown): unknown {
 }
 
 /** Symbol-stamped caches keyed by schema object identity. */
-const kZodWireSchema = Symbol("pi.schema.zod.wire");
 const kJsonWireSchema = Symbol("pi.schema.json.wire");
 const kArkWireSchema = Symbol("pi.schema.ark.wire");
 const kStrippedSchema = Symbol("pi.schema.descriptions.stripped");
 
-/**
- * Post-process Zod-emitted JSON Schema so it matches the wire shape providers
- * already expect from TypeBox-authored tools:
- *
- *   - Drop the `$schema` URL (providers parse the body, not the metadata).
- *   - Make fields with a `default` non-required (TypeBox/JSON-Schema semantics
- *     treat defaulted fields as optional; Zod inverts this and keeps them
- *     required at the input boundary, then materializes the default).
- *   - Strip the noisy safe-integer bounds Zod injects for `z.number().int()`.
- *
- * The empty-schema normalization (`{}` → `true`, see `normalizeEmptySchemas`)
- * runs separately from `toolWireSchema` so both Zod and TypeBox tools get it.
- */
-function postProcess(schema: Record<string, unknown>): Record<string, unknown> {
-	delete schema.$schema;
-	walk(schema, true);
-	normalizeArkPropertyComments(schema);
-	normalizeEmptySchemas(schema);
-	return schema;
-}
-
 function postProcessJsonSchema(schema: Record<string, unknown>): Record<string, unknown> {
-	walk(schema, false);
+	walk(schema);
 	normalizeArkPropertyComments(schema);
 	normalizeEmptySchemas(schema);
 	return schema;
 }
 
-const SAFE_INTEGER_MAX = Number.MAX_SAFE_INTEGER;
-const SAFE_INTEGER_MIN = Number.MIN_SAFE_INTEGER;
 const NULLABLE_SCALAR_TYPES = new Set(["string", "number", "integer", "boolean"]);
 
 const SCHEMA_DEFINING_SIBLING_KEYS = new Set([
@@ -226,11 +161,6 @@ function isNullVariant(schema: Record<string, unknown>): boolean {
 function isScalarVariant(schema: Record<string, unknown>): schema is Record<string, unknown> & { type: string } {
 	return typeof schema.type === "string" && NULLABLE_SCALAR_TYPES.has(schema.type);
 }
-
-function hasIntegerType(type: unknown): boolean {
-	return type === "integer" || (Array.isArray(type) && type.includes("integer"));
-}
-
 function copyNullableScalarConstraints(schema: Record<string, unknown>, scalarVariant: Record<string, unknown>): void {
 	for (const key in scalarVariant) {
 		if (key === "type" || key === "enum" || key === "const" || Object.hasOwn(schema, key)) continue;
@@ -455,9 +385,9 @@ function collapseConstUnionAnyOf(obj: Record<string, unknown>): void {
 	}
 }
 
-function walk(node: unknown, zodCleanup: boolean): void {
+function walk(node: unknown): void {
 	if (Array.isArray(node)) {
-		for (const child of node) walk(child, zodCleanup);
+		for (const child of node) walk(child);
 		return;
 	}
 	if (!node || typeof node !== "object") return;
@@ -465,48 +395,16 @@ function walk(node: unknown, zodCleanup: boolean): void {
 	rewriteNullableScalarAnyOf(obj);
 	inferBareEnumScalarType(obj);
 	collapseConstUnionAnyOf(obj);
-
-	if (zodCleanup) {
-		// Drop noise injected for `z.number().int()`.
-		if (hasIntegerType(obj.type)) {
-			if (obj.minimum === SAFE_INTEGER_MIN) delete obj.minimum;
-			if (obj.maximum === SAFE_INTEGER_MAX) delete obj.maximum;
-		}
-
-		// Make defaulted properties non-required.
-		if (Array.isArray(obj.required) && obj.properties && typeof obj.properties === "object") {
-			const properties = obj.properties as Record<string, unknown>;
-			const required = obj.required as string[];
-			const filtered = required.filter(name => {
-				const propertySchema = properties[name];
-				if (!propertySchema || typeof propertySchema !== "object") return true;
-				return !("default" in (propertySchema as Record<string, unknown>));
-			});
-			if (filtered.length !== required.length) {
-				if (filtered.length === 0) {
-					delete obj.required;
-				} else {
-					obj.required = filtered;
-				}
-			}
-		}
-	}
-
-	for (const k in obj) walk(obj[k], zodCleanup);
+	for (const k in obj) walk(obj[k]);
 }
 
 /**
- * Normalize `{}` (empty JSON Schema = `z.unknown()` / unconstrained value) to
- * boolean `true` in every schema-valued position. JSON Schema draft 2020-12
- * §4.3.1: `{}` and `true` are semantically equivalent ("any JSON value").
- * Grammar-constrained samplers (llama.cpp, etc.) treat the object form as
- * "generate an empty object" rather than "any JSON value", causing open-typed
- * fields like `extra.title` (from `z.record(z.string(), z.unknown())`) to
- * always emit `{}` instead of the intended string/number/etc. (issue #1179).
+ * Normalize `{}` (an unconstrained schema) to boolean `true` in every
+ * schema-valued position. JSON Schema draft 2020-12 §4.3.1 defines them as
+ * semantically equivalent. Grammar-constrained samplers often treat the object
+ * form as "generate an empty object" rather than "any JSON value".
  *
- * Mutates in place. Provider-agnostic — applied to every tool wire schema so
- * Anthropic, Google, OpenAI, Ollama, Bedrock, and Cursor all see the
- * normalized form, regardless of whether the source was Zod or TypeBox.
+ * Mutates in place and applies to every tool wire schema.
  */
 export function normalizeEmptySchemas(node: unknown): void {
 	if (Array.isArray(node)) {
@@ -539,23 +437,10 @@ export function normalizeEmptySchemas(node: unknown): void {
 	for (const k in obj) normalizeEmptySchemas(obj[k]);
 }
 
-/** Convert a Zod schema into the JSON Schema shape providers consume. */
-export function zodToWireSchema(schema: ZodType): Record<string, unknown> {
-	return stamp(schema, kZodWireSchema, s => {
-		// `target: "draft-2020-12"` matches what Anthropic's `input_schema` validator
-		// requires out of the box; our other provider sanitizers (OpenAI strict,
-		// Google, Anthropic CCA) already handle the superset structurally.
-		const raw = z.toJSONSchema(s, { target: "draft-2020-12" }) as Record<string, unknown>;
-		return postProcess(raw);
-	});
-}
-
 /**
  * Recursively set `additionalProperties: false` on declared object nodes so the
- * model-facing wire matches Zod's closed emission. Only nodes that declare
- * `properties` and carry neither `additionalProperties` nor `patternProperties`
- * are closed — open record/index nodes (which already carry one of those, e.g.
- * `additionalProperties: true` after empty-schema normalization) stay open.
+ * model-facing wire is closed. Only nodes that declare `properties` and carry
+ * neither `additionalProperties` nor `patternProperties` are closed.
  *
  * Traverses only schema-valued positions via the shared traversal-key constants
  * so it never descends into `default`/`examples`/`enum`/`const` instance data.
@@ -665,14 +550,6 @@ function pruneArkUndefinedUnionBranches(node: unknown): void {
 
 /**
  * Convert an ArkType schema into the JSON Schema shape providers consume.
- *
- * Mirrors {@link zodToWireSchema}: emit draft-2020-12, drop the `$schema`
- * metadata, run the JSON-schema post-process (NOT the Zod-only cleanup), then
- * close declared objects so the wire is `additionalProperties: false` like Zod.
- *
- * The `fallback` degrades any un-emittable node (a `.narrow()` predicate or a
- * morph) to its underlying base schema instead of throwing — matching Zod,
- * whose `.refine()`/`.transform()` likewise never appear in the wire schema.
  */
 export function arkToWireSchema(schema: Type): Record<string, unknown> {
 	return stamp(schema, kArkWireSchema, s => {
@@ -687,16 +564,12 @@ export function arkToWireSchema(schema: Type): Record<string, unknown> {
 
 /**
  * Resolve a tool's parameters to a JSON Schema object suitable for sending
- * over the wire. Zod schemas are converted (and cached); legacy TypeBox / raw
- * JSON Schema parameters are upgraded to draft 2020-12 (and cached).
- *
- * Zod schemas also receive Zod-artifact cleanup; both branches normalize
- * schema-valued positions and nullable scalar unions.
+ * over the wire. ArkType schemas are converted and cached; legacy TypeBox /
+ * raw JSON Schema parameters are upgraded to draft 2020-12 and cached.
  */
 export function toolWireSchema(tool: Tool): Record<string, unknown> {
 	const params: TSchema = tool.parameters;
 	if (isArkSchema(params)) return arkToWireSchema(params);
-	if (isZodSchema(params)) return zodToWireSchema(params);
 	return stamp(params as Record<string, unknown>, kJsonWireSchema, p => {
 		const raw = isArkJsonAst(p) ? arkJsonAstToWire(p) : p;
 		const upgraded = upgradeJsonSchemaTo202012(raw) as Record<string, unknown>;