veryfront 0.1.501 → 0.1.503

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,

package/src/src/agent/ag-ui-run-control.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { defineSchema } from "../schemas/index.js";
+import type { InferSchema } from "../extensions/schema/index.js";
 import { extractRequest } from "./ag-ui-request-shared.js";
 import {
   RunNotActiveError,
@@ -7,19 +8,24 @@ import {
   WaitNotPendingError,
 } from "./runtime/resume-session.js";
 
-const RESUME_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)\/resume$/;
-const CANCEL_PATH_REGEX = /^\/api\/ag-ui\/runs\/([^/]+)$/;
+const RESUME_PATH_REGEX = /^\/api\/runs\/([^/]+)\/resume$/;
+const CANCEL_PATH_REGEX = /^\/api\/runs\/([^/]+)$/;
 
-export const AgUiResumeSignalSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("tool_result"),
-    toolCallId: z.string().min(1).max(128),
-    result: z.unknown(),
-    isError: z.boolean().optional().default(false),
-  }),
-]);
+export const getAgUiResumeSignalSchema = defineSchema((v) =>
+  v.discriminatedUnion("type", [
+    v.object({
+      type: v.literal("tool_result"),
+      toolCallId: v.string().min(1).max(128),
+      result: v.unknown(),
+      isError: v.boolean().optional().default(false),
+    }),
+  ])
+);
 
-export type AgUiResumeSignal = z.infer<typeof AgUiResumeSignalSchema>;
+/** @deprecated Use getAgUiResumeSignalSchema() */
+export const AgUiResumeSignalSchema = getAgUiResumeSignalSchema();
+
+export type AgUiResumeSignal = InferSchema<ReturnType<typeof getAgUiResumeSignalSchema>>;
 
 type ResumeValue = {
   result: unknown;
@@ -67,7 +73,7 @@ export function createAgUiResumeHandler(
     }
 
     try {
-      const parsed = AgUiResumeSignalSchema.parse(await request.json());
+      const parsed = getAgUiResumeSignalSchema().parse(await request.json());
       const outcome = options.sessionManager.submitSignal(runId, {
         waitKey: parsed.toolCallId,
         value: {
@@ -78,11 +84,16 @@ export function createAgUiResumeHandler(
 
       return Response.json(outcome, { status: 200 });
     } 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 resume request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),

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

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { isResponseLike } from "./response-like.js";
 import {
   AgentRuntime,
@@ -482,11 +481,16 @@ export function createAgUiRuntimeHandler(
 
       throw new Error("createAgUiRuntimeHandler configuration became invalid during execution.");
     } 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 runtime request",
-            details: error.issues.map((issue) => ({
+            details: issues.map((issue) => ({
               path: issue.path,
               message: issue.message,
             })),