veryfront 0.1.502 → 0.1.504

package/src/extensions/ext-zod/src/json-schema.ts

@@ -0,0 +1,311 @@
+/**
+ * Zod-to-JSON-Schema converter used by the `SchemaValidator` adapter.
+ *
+ * Operates directly on zod's internal `_def` shape (covers both v3 and v4)
+ * because zod ships no first-class JSON-Schema export. Confined to
+ * `extensions/ext-zod/` so the rest of the codebase never has to import zod
+ * to learn what a tool's input schema looks like.
+ *
+ * @module extensions/ext-zod/json-schema
+ */
+
+import type { z } from "zod";
+import type { JsonSchema } from "../../../src/extensions/schema/index.js";
+
+/** Zod internal _def shape — covers fields from both v3 and v4. */
+interface ZodDef {
+  typeName?: string; // v3
+  type?: string; // v4
+  value?: unknown; // v3 literal
+  values?: unknown; // v3 enum / v4 literal
+  entries?: Record<string, unknown>; // v4 enum
+  description?: string; // v3 description metadata
+  shape?: (() => Record<string, z.ZodTypeAny>) | Record<string, z.ZodTypeAny>;
+  element?: z.ZodTypeAny; // v4 array/record
+  items?: z.ZodTypeAny[]; // tuple
+  options?: z.ZodTypeAny[] | Map<string, z.ZodTypeAny>; // union
+  valueType?: z.ZodTypeAny; // record
+  catchall?: z.ZodTypeAny; // object unknown-key policy / catchall
+  unknownKeys?: "strip" | "passthrough" | "strict"; // v3 object unknown-key policy
+  innerType?: z.ZodTypeAny; // optional/nullable/default (v3)
+  schema?: z.ZodTypeAny; // effects/optional/nullable (v3/v4)
+  in?: z.ZodTypeAny; // pipe input (v4)
+  getter?: () => z.ZodTypeAny; // lazy
+  defaultValue?: (() => unknown) | unknown;
+}
+
+interface ConversionContext {
+  seen: WeakSet<object>;
+}
+
+const LITERAL_TYPE_MAP: Record<string, "string" | "number" | "boolean"> = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+};
+
+function getLiteralType(value: unknown): "string" | "number" | "boolean" | undefined {
+  return LITERAL_TYPE_MAP[typeof value];
+}
+
+function getDef(schema: z.ZodTypeAny): ZodDef {
+  return schema._def as ZodDef;
+}
+
+/** Get the internal type tag from a zod schema (_def.typeName in v3, _def.type in v4). */
+function getTypeTag(schema: z.ZodTypeAny): string | undefined {
+  const def = getDef(schema);
+  return def.typeName ?? def.type;
+}
+
+export function zodToJsonSchema(schema: z.ZodTypeAny): JsonSchema {
+  return convertSchema(schema, { seen: new WeakSet() });
+}
+
+function convertSchema(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  // Guard against invalid schemas (can happen with different zod instances in npm bundle)
+  if (!schema || typeof schema !== "object" || !("_def" in schema)) {
+    throw new Error("Invalid Zod schema: missing _def property");
+  }
+
+  const { schema: unwrapped, nullable } = unwrapSchema(schema);
+  const json = convert(unwrapped, context);
+  const description = getDescription(schema) ?? getDescription(unwrapped);
+  if (description && json.description === undefined) json.description = description;
+
+  return nullable ? { anyOf: [json, { type: "null" }] } : json;
+}
+
+export function isOptionalSchema(schema: z.ZodTypeAny): boolean {
+  return unwrapSchema(schema).optional || hasDefaultSchema(schema);
+}
+
+function convert(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  if (context.seen.has(schema)) return {};
+  context.seen.add(schema);
+
+  try {
+    return convertInner(schema, context);
+  } finally {
+    context.seen.delete(schema);
+  }
+}
+
+function convertInner(schema: z.ZodTypeAny, context: ConversionContext): JsonSchema {
+  const tag = getTypeTag(schema);
+  const def = getDef(schema);
+
+  switch (tag) {
+    case "ZodString":
+    case "string":
+      return { type: "string" };
+
+    case "ZodNumber":
+    case "number":
+      return { type: "number" };
+
+    case "ZodBoolean":
+    case "boolean":
+      return { type: "boolean" };
+
+    case "ZodBigInt":
+    case "bigint":
+      return { type: "integer" };
+
+    case "ZodLiteral":
+    case "literal": {
+      // v3: _def.value, v4: _def.values (array of accepted values)
+      const literal = def.value ?? (Array.isArray(def.values) ? def.values[0] : def.values);
+      return { const: literal, type: getLiteralType(literal) };
+    }
+
+    case "ZodEnum":
+    case "ZodNativeEnum":
+    case "enum": {
+      // v3: _def.values (array), v4: _def.entries (object {key: value})
+      const values = def.values ?? (def.entries ? Object.values(def.entries) : []);
+      if (Array.isArray(values)) {
+        return { type: "string", enum: values };
+      }
+      // Native enum: filter out reverse-mapped numeric keys
+      return {
+        enum: Object.values(values).filter((value) => typeof value !== "number"),
+      };
+    }
+
+    case "ZodObject":
+    case "object": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      const properties: Record<string, JsonSchema> = {};
+      const required: string[] = [];
+
+      for (const [key, value] of Object.entries(shape ?? {})) {
+        const zodSchema = value as z.ZodTypeAny;
+        properties[key] = convertSchema(zodSchema, context);
+        if (!isOptionalSchema(zodSchema)) required.push(key);
+      }
+
+      const json: JsonSchema = { type: "object", properties };
+      if (required.length) json.required = required;
+      const additionalProperties = getObjectAdditionalProperties(def, context);
+      if (additionalProperties !== undefined) json.additionalProperties = additionalProperties;
+
+      return json;
+    }
+
+    case "ZodArray":
+    case "array": {
+      // v3: _def.type (item schema), v4: _def.element (item schema)
+      const itemType = def.element ?? (def.type as unknown as z.ZodTypeAny | undefined);
+      if (!itemType || typeof itemType === "string") return { type: "array" };
+      return { type: "array", items: convertSchema(itemType, context) };
+    }
+
+    case "ZodTuple":
+    case "tuple": {
+      const items = def.items ?? [];
+      return {
+        type: "array",
+        prefixItems: items.map((item: z.ZodTypeAny) => convertSchema(item, context)),
+        minItems: items.length,
+        maxItems: items.length,
+      };
+    }
+
+    case "ZodUnion":
+    case "ZodDiscriminatedUnion":
+    case "union": {
+      const options = def.options ?? [];
+      const optionArray = options instanceof Map ? Array.from(options.values()) : options;
+      return { anyOf: optionArray.map((option: z.ZodTypeAny) => convertSchema(option, context)) };
+    }
+
+    case "ZodRecord":
+    case "record": {
+      const valueSchema = def.valueType ?? def.element;
+      if (!valueSchema) return { type: "object" };
+      return { type: "object", additionalProperties: convertSchema(valueSchema, context) };
+    }
+
+    case "ZodDefault":
+    case "default": {
+      const innerType = def.innerType ?? def.schema;
+      if (!innerType) return { type: "object" };
+      const inner = convertSchema(innerType, context);
+      const defaultValue = typeof def.defaultValue === "function"
+        ? def.defaultValue()
+        : def.defaultValue;
+
+      if (typeof inner === "object" && !("anyOf" in inner) && defaultValue !== undefined) {
+        inner.default = defaultValue;
+      }
+
+      return inner;
+    }
+
+    case "ZodLazy":
+    case "lazy":
+      return def.getter ? convert(def.getter(), context) : { type: "object" };
+
+    case "ZodEffects":
+    case "pipe": {
+      // v3: ZodEffects wraps schema in _def.schema
+      // v4: pipe wraps in _def.in (input schema)
+      const innerSchema = def.schema ?? def.in;
+      return innerSchema ? convert(innerSchema, context) : { type: "object" };
+    }
+
+    default:
+      return { type: "object" };
+  }
+}
+
+function getObjectAdditionalProperties(
+  def: ZodDef,
+  context: ConversionContext,
+): boolean | JsonSchema | undefined {
+  if (def.unknownKeys === "passthrough") return true;
+  if (def.unknownKeys === "strict") return false;
+  if (def.unknownKeys === "strip") return undefined;
+
+  if (!def.catchall) return undefined;
+
+  const catchallTag = getTypeTag(def.catchall);
+  if (catchallTag === "unknown" || catchallTag === "ZodUnknown") return true;
+  if (catchallTag === "never" || catchallTag === "ZodNever") return false;
+  return convertSchema(def.catchall, context);
+}
+
+function unwrapSchema(
+  schema: z.ZodTypeAny,
+): { schema: z.ZodTypeAny; nullable: boolean; optional: boolean } {
+  let current: z.ZodTypeAny = schema;
+  let nullable = false;
+  let optional = false;
+
+  while (true) {
+    const tag = getTypeTag(current);
+    const def = getDef(current);
+
+    switch (tag) {
+      case "ZodNullable":
+      case "nullable":
+        nullable = true;
+        current = (def.innerType ?? def.schema)!;
+        break;
+
+      case "ZodOptional":
+      case "optional":
+        optional = true;
+        current = (def.innerType ?? def.schema)!;
+        break;
+
+      case "ZodEffects":
+      case "pipe":
+        current = def.schema ?? def.in ?? current;
+        if (current === schema) return { schema: current, nullable, optional };
+        break;
+
+      default:
+        return { schema: current, nullable, optional };
+    }
+  }
+}
+
+function hasDefaultSchema(schema: z.ZodTypeAny): boolean {
+  let current: z.ZodTypeAny = schema;
+
+  while (true) {
+    const tag = getTypeTag(current);
+    const def = getDef(current);
+
+    switch (tag) {
+      case "ZodDefault":
+      case "default":
+        return true;
+
+      case "ZodNullable":
+      case "nullable":
+      case "ZodOptional":
+      case "optional":
+      case "ZodEffects":
+      case "pipe": {
+        const inner = def.innerType ?? def.schema ?? def.in;
+        if (!inner || inner === current) return false;
+        current = inner;
+        break;
+      }
+
+      default:
+        return false;
+    }
+  }
+}
+
+function getDescription(schema: z.ZodTypeAny): string | undefined {
+  const direct = (schema as { description?: unknown }).description;
+  if (typeof direct === "string") return direct;
+
+  const defDescription = getDef(schema).description;
+  return typeof defDescription === "string" ? defDescription : undefined;
+}

package/src/src/agent/ag-ui-detached-start.ts

@@ -1,8 +1,9 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { INVALID_ARGUMENT } from "../errors/index.js";
 import { streamDataStreamEvents } from "./data-stream.js";
-import { AgUiRequestSchema, normalizeAgUiMessages } from "./ag-ui-host-support.js";
+import { getAgUiRequestSchema, normalizeAgUiMessages } from "./ag-ui-host-support.js";
 import { extractRequest } from "./ag-ui-request-shared.js";
 import { type AgUiResumeValue, buildMergedAgUiTools } from "./ag-ui-tool-shared.js";
 import {
@@ -14,7 +15,9 @@ import type { Agent } from "./types.js";
 import type { ChatUiMessage, MessageMetadata } from "../chat/types.js";
 
 const AGENT_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-const AG_UI_DETACHED_RUN_ID_SCHEMA = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
+const getAgUiDetachedRunIdSchema = defineSchema((v) =>
+  v.string().min(1).max(128).regex(AGENT_ID_PATTERN)
+);
 
 type AgUiContextValue =
   | Record<string, unknown>
@@ -69,20 +72,33 @@ async function drainRuntimeStream(
   }
 }
 
-export const AgUiDetachedStartRequestSchema = AgUiRequestSchema.extend({
-  threadId: z.string().uuid(),
-  runId: AG_UI_DETACHED_RUN_ID_SCHEMA,
-});
-
-export const AgUiDetachedStartAcceptedSchema = z.object({
-  accepted: z.literal(true),
-  duplicate: z.boolean(),
-  runId: AG_UI_DETACHED_RUN_ID_SCHEMA,
-  threadId: z.string().uuid(),
-});
-
-export type AgUiDetachedStartRequest = z.infer<typeof AgUiDetachedStartRequestSchema>;
-export type AgUiDetachedStartAccepted = z.infer<typeof AgUiDetachedStartAcceptedSchema>;
+export const getAgUiDetachedStartRequestSchema = defineSchema((v) =>
+  getAgUiRequestSchema().extend({
+    threadId: v.string().uuid(),
+    runId: getAgUiDetachedRunIdSchema(),
+  })
+);
+
+export const getAgUiDetachedStartAcceptedSchema = defineSchema((v) =>
+  v.object({
+    accepted: v.literal(true),
+    duplicate: v.boolean(),
+    runId: getAgUiDetachedRunIdSchema(),
+    threadId: v.string().uuid(),
+  })
+);
+
+/** @deprecated Use getAgUiDetachedStartRequestSchema() */
+export const AgUiDetachedStartRequestSchema = getAgUiDetachedStartRequestSchema();
+/** @deprecated Use getAgUiDetachedStartAcceptedSchema() */
+export const AgUiDetachedStartAcceptedSchema = getAgUiDetachedStartAcceptedSchema();
+
+export type AgUiDetachedStartRequest = InferSchema<
+  ReturnType<typeof getAgUiDetachedStartRequestSchema>
+>;
+export type AgUiDetachedStartAccepted = InferSchema<
+  ReturnType<typeof getAgUiDetachedStartAcceptedSchema>
+>;
 
 function toDetachedAgUiMessageMetadata(
   metadata: MessageMetadata | undefined,
@@ -121,7 +137,9 @@ export function buildDetachedAgUiStartRequest(input: {
   forwardedProps?: Record<string, unknown>;
   createThreadId?: () => string;
 }): AgUiDetachedStartRequest {
-  const effectiveThreadId = z.string().uuid().safeParse(input.threadId).success
+  const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+    .test(input.threadId);
+  const effectiveThreadId = isValidUuid
     ? input.threadId
     : (input.createThreadId?.() ?? dntShim.crypto.randomUUID());
   const effectiveMessages: AgUiDetachedStartRequest["messages"] = input.messages.length > 0
@@ -371,18 +389,23 @@ export function createAgUiDetachedStartHandler(
     const request = extractRequest(requestOrCtx);
 
     try {
-      const parsed = AgUiDetachedStartRequestSchema.parse(await request.json());
+      const parsed = getAgUiDetachedStartRequestSchema().parse(await request.json());
       return await executeAgUiDetachedStart(options, {
         request: parsed,
         rawRequest: request,
         requestOrCtx,
       });
     } catch (error) {
-      if (error instanceof z.ZodError) {
+      if (
+        error instanceof Error &&
+        "issues" in error &&
+        Array.isArray((error as Record<string, unknown>).issues)
+      ) {
+        const issues = (error as { issues: Array<{ path: unknown[]; message: string }> }).issues;
         return Response.json(
           {
             error: "Invalid AG-UI detached start request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),

package/src/src/agent/ag-ui-forwarded-context.ts

@@ -1,8 +1,9 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { Schema } from "../extensions/schema/index.js";
 import type { AgUiRuntimeRequest } from "./runtime-ag-ui-contract.js";
 
 export type AgUiForwardedConfigOptions<TConfig> = {
-  schema: z.ZodType<TConfig>;
+  schema: Schema<TConfig>;
   namespace?: string;
 };
 
@@ -53,7 +54,7 @@ export function parseAgUiContextBoolean(raw: string | undefined): boolean | unde
 
 export function parseAgUiContextSchema<TValue>(
   raw: string | undefined,
-  schema: z.ZodType<TValue>,
+  schema: Schema<TValue>,
 ): TValue | undefined {
   const parsed = parseAgUiContextJsonValue(raw);
   const result = schema.safeParse(parsed);
@@ -64,7 +65,8 @@ export function deriveAgUiForwardedConfig<TConfig>(
   input: Pick<AgUiRuntimeRequest, "forwardedProps">,
   options: AgUiForwardedConfigOptions<TConfig>,
 ): TConfig | undefined {
-  const forwardedProps = z.record(z.string(), z.unknown()).safeParse(input.forwardedProps);
+  const getRecordSchema = defineSchema((v) => v.record(v.string(), v.unknown()));
+  const forwardedProps = getRecordSchema().safeParse(input.forwardedProps);
   if (!forwardedProps.success) {
     return undefined;
   }

package/src/src/agent/ag-ui-handler.ts

@@ -1,5 +1,4 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { z } from "zod";
 import { isResponseLike } from "./response-like.js";
 import { getAgent } from "./composition/index.js";
 import type { Agent } from "./types.js";
@@ -360,11 +359,16 @@ export function createAgUiHandler(
 
       return await createAgUiDirectStreamResponse(agent, parsed, context);
     } catch (error) {
-      if (error instanceof z.ZodError) {
+      if (
+        error instanceof Error &&
+        "issues" in error &&
+        Array.isArray((error as Record<string, unknown>).issues)
+      ) {
+        const issues = (error as { issues: Array<{ path: unknown[]; message: string }> }).issues;
         return Response.json(
           {
             error: "Invalid AG-UI request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),

package/src/src/agent/ag-ui-host-support.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { formatAgUiEvent } from "../internal-agents/ag-ui-sse.js";
 import type { Message } from "./types.js";
 import { parseAgUiJsonRequestOrError } from "./ag-ui-request-shared.js";
@@ -30,70 +31,87 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-const AgUiRunIdSchema = z.string().min(1).max(128).regex(AGENT_ID_PATTERN);
-
-export const AgUiInjectedToolSchema = z.object({
-  name: z.string().min(1).max(128),
-  description: z.string().max(1024).optional(),
-  parameters: z.record(z.string(), z.unknown()).optional().refine(
-    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES),
-    { message: "Tool parameters must be less than 16 KB" },
-  ),
-});
-
-export const AgUiContextItemSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("text"),
-    title: z.string().max(256).optional(),
-    text: z.string().max(MAX_CONTEXT_ITEM_BYTES),
-  }),
-  z.object({
-    type: z.literal("json"),
-    title: z.string().max(256).optional(),
-    data: z.record(z.string(), z.unknown()).refine(
-      (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES),
-      { message: "JSON context item must be less than 16 KB" },
+const getAgUiRunIdSchema = defineSchema((v) => v.string().min(1).max(128).regex(AGENT_ID_PATTERN));
+
+export const getAgUiInjectedToolSchema = defineSchema((v) =>
+  v.object({
+    name: v.string().min(1).max(128),
+    description: v.string().max(1024).optional(),
+    parameters: v.record(v.string(), v.unknown()).optional().refine(
+      (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_TOOL_PARAMETERS_BYTES),
+      { message: "Tool parameters must be less than 16 KB" },
+    ),
+  })
+);
+
+export const getAgUiContextItemSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      type: v.literal("text"),
+      title: v.string().max(256).optional(),
+      text: v.string().max(MAX_CONTEXT_ITEM_BYTES),
+    }),
+    v.object({
+      type: v.literal("json"),
+      title: v.string().max(256).optional(),
+      data: v.record(v.string(), v.unknown()).refine(
+        (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_ITEM_BYTES),
+        { message: "JSON context item must be less than 16 KB" },
+      ),
+    }),
+    v.object({
+      type: v.literal("resource"),
+      title: v.string().max(256).optional(),
+      uri: v.string().max(2048),
+      mimeType: v.string().max(256).optional(),
+      text: v.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
+    }),
+  ])
+);
+
+const getAgUiMessagePartSchema = defineSchema((v) =>
+  v.object({ type: v.string().min(1) }).passthrough()
+);
+
+const getAgUiMessageSchema = defineSchema((v) =>
+  v.object({
+    id: v.string().min(1),
+    role: v.enum(["user", "assistant", "system", "tool"]),
+    parts: v.array(getAgUiMessagePartSchema()).default([]),
+    metadata: v.record(v.string(), v.unknown()).optional(),
+    createdAt: v.string().optional(),
+  })
+);
+
+export const getAgUiRequestSchema = defineSchema((v) =>
+  v.object({
+    threadId: v.string().uuid().optional(),
+    runId: getAgUiRunIdSchema().optional(),
+    messages: v.array(getAgUiMessageSchema()).min(1).max(MAX_MESSAGES_PER_REQUEST),
+    tools: v.array(getAgUiInjectedToolSchema()).max(50).default([]),
+    context: v.array(getAgUiContextItemSchema()).max(10).default([]).refine(
+      (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES),
+      { message: "context must be less than 64 KB total" },
+    ),
+    forwardedProps: v.record(v.string(), v.unknown()).optional().refine(
+      (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES),
+      { message: "forwardedProps must be less than 64 KB" },
     ),
-  }),
-  z.object({
-    type: z.literal("resource"),
-    title: z.string().max(256).optional(),
-    uri: z.string().max(2048),
-    mimeType: z.string().max(256).optional(),
-    text: z.string().max(MAX_CONTEXT_ITEM_BYTES).optional(),
-  }),
-]);
-
-const AgUiMessagePartSchema = z.object({ type: z.string().min(1) }).passthrough();
-
-const AgUiMessageSchema = z.object({
-  id: z.string().min(1),
-  role: z.enum(["user", "assistant", "system", "tool"]),
-  parts: z.array(AgUiMessagePartSchema).default([]),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string().optional(),
-});
-
-export const AgUiRequestSchema = z.object({
-  threadId: z.string().uuid().optional(),
-  runId: AgUiRunIdSchema.optional(),
-  messages: z.array(AgUiMessageSchema).min(1).max(MAX_MESSAGES_PER_REQUEST),
-  tools: z.array(AgUiInjectedToolSchema).max(50).default([]),
-  context: z.array(AgUiContextItemSchema).max(10).default([]).refine(
-    (value) => isWithinJsonSizeLimit(value, MAX_CONTEXT_TOTAL_BYTES),
-    { message: "context must be less than 64 KB total" },
-  ),
-  forwardedProps: z.record(z.string(), z.unknown()).optional().refine(
-    (value) => value === undefined || isWithinJsonSizeLimit(value, MAX_FORWARDED_PROPS_BYTES),
-    { message: "forwardedProps must be less than 64 KB" },
-  ),
-  model: z.string().optional(),
-  maxOutputTokens: z.number().int().positive().optional(),
-});
-
-export type AgUiInjectedTool = z.infer<typeof AgUiInjectedToolSchema>;
-export type AgUiContextItem = z.infer<typeof AgUiContextItemSchema>;
-export type AgUiRequest = z.infer<typeof AgUiRequestSchema>;
+    model: v.string().optional(),
+    maxOutputTokens: v.number().int().positive().optional(),
+  })
+);
+
+/** @deprecated Use getAgUiInjectedToolSchema() */
+export const AgUiInjectedToolSchema = getAgUiInjectedToolSchema();
+/** @deprecated Use getAgUiContextItemSchema() */
+export const AgUiContextItemSchema = getAgUiContextItemSchema();
+/** @deprecated Use getAgUiRequestSchema() */
+export const AgUiRequestSchema = getAgUiRequestSchema();
+
+export type AgUiInjectedTool = InferSchema<ReturnType<typeof getAgUiInjectedToolSchema>>;
+export type AgUiContextItem = InferSchema<ReturnType<typeof getAgUiContextItemSchema>>;
+export type AgUiRequest = InferSchema<ReturnType<typeof getAgUiRequestSchema>>;
 
 function normalizeToolArgs(part: Record<string, unknown>): Record<string, unknown> {
   if (isRecord(part.args)) return part.args;
@@ -168,7 +186,7 @@ function normalizeMessagePart(part: Record<string, unknown>): Message["parts"][n
 }
 
 export async function parseAgUiRequest(request: Request): Promise<AgUiRequest> {
-  return AgUiRequestSchema.parse(await request.json());
+  return getAgUiRequestSchema().parse(await request.json());
 }
 
 export async function parseAgUiRequestOrError(
@@ -189,7 +207,7 @@ export function normalizeAgUiMessages(messages: AgUiRequest["messages"]): Messag
       .filter((part): part is Message["parts"][number] => part !== null),
     ...(message.createdAt ? { timestamp: Date.parse(message.createdAt) || undefined } : {}),
     ...(message.metadata ? { metadata: message.metadata } : {}),
-  }));
+  })) as any;
 }
 
 export function createAgUiRunErrorEvent(message: string, code?: string): AgUiSseEvent {

package/src/src/agent/ag-ui-request-shared.ts

@@ -1,6 +1,20 @@
-import { z } from "zod";
 import { INVALID_ARGUMENT } from "../errors/index.js";
 
+/**
+ * Detects a validation error thrown by a `Schema.parse()` call. Works with
+ * both the contract-DSL adapter (ext-zod wraps `ZodError` and sets `issues`)
+ * and raw zod errors.
+ */
+function isSchemaValidationError(
+  error: unknown,
+): error is Error & { issues: ReadonlyArray<{ path: (string | number)[]; message: string }> } {
+  return (
+    error instanceof Error &&
+    "issues" in error &&
+    Array.isArray((error as Record<string, unknown>).issues)
+  );
+}
+
 export function isRequest(value: unknown): value is Request {
   return (
     typeof value === "object" &&
@@ -34,7 +48,7 @@ export async function parseAgUiJsonRequestOrError<T>(
   try {
     return await parseRequest();
   } catch (error) {
-    if (error instanceof z.ZodError) {
+    if (isSchemaValidationError(error)) {
       return Response.json(
         {
           error: errorLabel,