feat(core): support valibot and other schema libraries via xsschema, not just zod

Author: baseballyama

.changeset/fair-memes-open.md

@@ -0,0 +1,5 @@
+---
+"@voltagent/core": minor
+---
+
+feat(core): support valibot and other schema libraries via xsschema, not just zod

packages/core/package.json

@@ -38,7 +38,9 @@
     "npm-check-updates": "^17.1.18",
     "uuid": "^9.0.1",
     "ws": "^8.18.1",
-    "zod": "^3.24.2"
+    "xsschema": "0.3.0-beta.2",
+    "zod": "^3.25.30",
+    "zod-to-openapi": "^0.2.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",
@@ -48,8 +50,5 @@
     "ts-jest": "^29.1.0",
     "tsup": "^6.7.0",
     "typescript": "^5.0.4"
-  },
-  "peerDependencies": {
-    "zod": "^3.24.2"
   }
 }

packages/core/src/agent/index.spec.ts

@@ -1,5 +1,6 @@
 // @ts-ignore - To prevent errors when loading Jest mocks
 import { z } from "zod";
+import type * as xsschema from "xsschema";
 import { AgentEventEmitter } from "../events";
 import type { MemoryMessage } from "../memory/types";
 import { AgentRegistry } from "../server/registry";
@@ -232,11 +233,13 @@ class MockProvider implements LLMProvider<MockModelType> {
     };
   }
 
-  async generateObject<T extends z.ZodType>(options: {
+  async generateObject<T extends xsschema.Schema>(options: {
     messages: BaseMessage[];
     model: MockModelType;
     schema: T;
-  }): Promise<ProviderObjectResponse<MockGenerateObjectResult<z.infer<T>>, z.infer<T>>> {
+  }): Promise<
+    ProviderObjectResponse<MockGenerateObjectResult<xsschema.Infer<T>>, xsschema.Infer<T>>
+  > {
     this.generateObjectCalls++;
     this.lastMessages = options.messages;
 
@@ -245,7 +248,7 @@ class MockProvider implements LLMProvider<MockModelType> {
         name: "John Doe",
         age: 30,
         hobbies: ["reading", "gaming"],
-      } as z.infer<T>,
+      } as xsschema.Infer<T>,
     };
 
     return {
@@ -260,11 +263,13 @@ class MockProvider implements LLMProvider<MockModelType> {
     };
   }
 
-  async streamObject<T extends z.ZodType>(options: {
+  async streamObject<T extends xsschema.Schema>(options: {
     messages: BaseMessage[];
     model: MockModelType;
     schema: T;
-  }): Promise<ProviderObjectStreamResponse<MockStreamObjectResult<z.infer<T>>, z.infer<T>>> {
+  }): Promise<
+    ProviderObjectStreamResponse<MockStreamObjectResult<xsschema.Infer<T>>, xsschema.Infer<T>>
+  > {
     this.streamObjectCalls++;
     this.lastMessages = options.messages;
 
@@ -278,9 +283,9 @@ class MockProvider implements LLMProvider<MockModelType> {
       },
     });
 
-    const partialObjectStream = new ReadableStream<Partial<z.infer<T>>>({
+    const partialObjectStream = new ReadableStream<Partial<xsschema.Infer<T>>>({
       start(controller) {
-        controller.enqueue({ name: "John" } as Partial<z.infer<T>>);
+        controller.enqueue({ name: "John" } as Partial<xsschema.Infer<T>>);
         controller.close();
       },
     });

packages/core/src/agent/index.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import type * as xsschema from "xsschema";
 import { AgentEventEmitter } from "../events";
 import type { EventStatus, EventUpdater } from "../events";
 import { MemoryManager } from "../memory";
@@ -1295,7 +1295,7 @@ export class Agent<TProvider extends { llm: LLMProvider<unknown> }> {
   /**
    * Generate a structured object response
    */
-  async generateObject<T extends z.ZodType>(
+  async generateObject<T extends xsschema.Schema>(
     input: string | BaseMessage[],
     schema: T,
     options: PublicGenerateOptions = {},
@@ -1400,7 +1400,7 @@ export class Agent<TProvider extends { llm: LLMProvider<unknown> }> {
         status: "completed" as any,
       });
       operationContext.isActive = false;
-      const standardizedOutput: StandardizedObjectResult<z.infer<T>> = {
+      const standardizedOutput: StandardizedObjectResult<xsschema.Infer<T>> = {
         object: response.object,
         usage: response.usage,
         finishReason: response.finishReason,
@@ -1448,7 +1448,7 @@ export class Agent<TProvider extends { llm: LLMProvider<unknown> }> {
   /**
    * Stream a structured object response
    */
-  async streamObject<T extends z.ZodType>(
+  async streamObject<T extends xsschema.Schema>(
     input: string | BaseMessage[],
     schema: T,
     options: PublicGenerateOptions = {},
@@ -1535,7 +1535,7 @@ export class Agent<TProvider extends { llm: LLMProvider<unknown> }> {
             await (provider.onStepFinish as (step: StepWithContent) => Promise<void>)(step);
           }
         },
-        onFinish: async (result: StreamObjectFinishResult<z.infer<T>>) => {
+        onFinish: async (result: StreamObjectFinishResult<xsschema.Infer<T>>) => {
           if (!operationContext.isActive) {
             return;
           }
@@ -1565,7 +1565,7 @@ export class Agent<TProvider extends { llm: LLMProvider<unknown> }> {
             context: operationContext,
           });
           if (provider?.onFinish) {
-            await (provider.onFinish as StreamObjectOnFinishCallback<z.infer<T>>)(result);
+            await (provider.onFinish as StreamObjectOnFinishCallback<xsschema.Infer<T>>)(result);
           }
         },
         onError: async (error: VoltAgentError) => {

packages/core/src/agent/providers/base/types.ts

@@ -1,4 +1,4 @@
-import type { z } from "zod";
+import type * as xsschema from "xsschema";
 import type {
   ProviderOptions,
   ToolExecutionContext,
@@ -191,7 +191,7 @@ export type BaseMessage = {
 };
 
 // Schema types
-export type ToolSchema = z.ZodType;
+export type ToolSchema = xsschema.Schema;
 
 // Base tool types
 export type ToolExecuteOptions = {
@@ -274,7 +274,7 @@ export interface StreamTextOptions<TModel> {
   toolExecutionContext?: ToolExecutionContext;
 }
 
-export interface GenerateObjectOptions<TModel, TSchema extends z.ZodType> {
+export interface GenerateObjectOptions<TModel, TSchema extends xsschema.Schema> {
   messages: BaseMessage[];
   model: TModel;
   schema: TSchema;
@@ -284,13 +284,13 @@ export interface GenerateObjectOptions<TModel, TSchema extends z.ZodType> {
   toolExecutionContext?: ToolExecutionContext;
 }
 
-export interface StreamObjectOptions<TModel, TSchema extends z.ZodType> {
+export interface StreamObjectOptions<TModel, TSchema extends xsschema.Schema> {
   messages: BaseMessage[];
   model: TModel;
   schema: TSchema;
   provider?: ProviderOptions;
   onStepFinish?: StepFinishCallback;
-  onFinish?: StreamObjectOnFinishCallback<z.infer<TSchema>>;
+  onFinish?: StreamObjectOnFinishCallback<xsschema.Infer<TSchema>>;
   onError?: StreamOnErrorCallback;
   signal?: AbortSignal;
   toolExecutionContext?: ToolExecutionContext;
@@ -368,13 +368,15 @@ export type LLMProvider<TProvider> = {
    * Implementers should catch underlying SDK/API errors and throw a VoltAgentError.
    * @throws {VoltAgentError} If an error occurs during generation.
    */
-  generateObject<TSchema extends z.ZodType>(
+  generateObject<TSchema extends xsschema.Schema>(
     options: GenerateObjectOptions<InferModel<TProvider>, TSchema>,
-  ): Promise<ProviderObjectResponse<InferGenerateObjectResponse<TProvider>, z.infer<TSchema>>>;
+  ): Promise<
+    ProviderObjectResponse<InferGenerateObjectResponse<TProvider>, xsschema.Infer<TSchema>>
+  >;
 
-  streamObject<TSchema extends z.ZodType>(
+  streamObject<TSchema extends xsschema.Schema>(
     options: StreamObjectOptions<InferModel<TProvider>, TSchema>,
-  ): Promise<ProviderObjectStreamResponse<InferStreamResponse<TProvider>, z.infer<TSchema>>>;
+  ): Promise<ProviderObjectStreamResponse<InferStreamResponse<TProvider>, xsschema.Infer<TSchema>>>;
 
   // Message conversion methods
   toMessage(message: BaseMessage): InferMessage<TProvider>;

packages/core/src/server/api.ts

@@ -1,8 +1,7 @@
-import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { WebSocketServer } from "ws";
 import type { WebSocket } from "ws";
-import { z } from "zod";
+import type * as xsschema from "xsschema";
 import { OpenAPIHono } from "@hono/zod-openapi";
 import { swaggerUI } from "@hono/swagger-ui";
 import type { AgentHistoryEntry } from "../agent/history";
@@ -25,7 +24,6 @@ import {
   type ErrorSchema,
   type TextResponseSchema,
   type ObjectResponseSchema,
-  type AgentResponseSchema,
   type TextRequestSchema,
   type ObjectRequestSchema,
 } from "./api.routes";
@@ -164,7 +162,7 @@ app.openapi(getAgentsRoute, (c) => {
     });
 
     // Define the exact success response type based on the route schema
-    type SuccessResponse = z.infer<
+    type SuccessResponse = xsschema.Infer<
       (typeof getAgentsRoute.responses)[200]["content"]["application/json"]["schema"]
     >;
 
@@ -177,7 +175,9 @@ app.openapi(getAgentsRoute, (c) => {
   } catch (error) {
     console.error("Failed to get agents:", error);
     return c.json(
-      { success: false, error: "Failed to retrieve agents" } satisfies z.infer<typeof ErrorSchema>,
+      { success: false, error: "Failed to retrieve agents" } satisfies xsschema.Infer<
+        typeof ErrorSchema
+      >,
       500,
     );
   }
@@ -259,22 +259,24 @@ app.openapi(textRoute, async (c) => {
 
   if (!agent) {
     return c.json(
-      { success: false, error: "Agent not found" } satisfies z.infer<typeof ErrorSchema>,
+      { success: false, error: "Agent not found" } satisfies xsschema.Infer<typeof ErrorSchema>,
       404,
     );
   }
 
   try {
-    const { input, options = {} } = c.req.valid("json") as z.infer<typeof TextRequestSchema>;
+    const { input, options = {} } = c.req.valid("json") as xsschema.Infer<typeof TextRequestSchema>;
 
     const response = await agent.generateText(input, options);
-    return c.json({ success: true, data: response } satisfies z.infer<typeof TextResponseSchema>);
+    return c.json({ success: true, data: response } satisfies xsschema.Infer<
+      typeof TextResponseSchema
+    >);
   } catch (error) {
     return c.json(
       {
         success: false,
         error: error instanceof Error ? error.message : "Failed to generate text",
-      } satisfies z.infer<typeof ErrorSchema>,
+      } satisfies xsschema.Infer<typeof ErrorSchema>,
       500,
     );
   }
@@ -288,7 +290,7 @@ app.openapi(streamRoute, async (c) => {
 
   if (!agent) {
     return c.json(
-      { success: false, error: "Agent not found" } satisfies z.infer<typeof ErrorSchema>,
+      { success: false, error: "Agent not found" } satisfies xsschema.Infer<typeof ErrorSchema>,
       404,
     );
   }
@@ -300,7 +302,7 @@ app.openapi(streamRoute, async (c) => {
         maxTokens: 4000,
         temperature: 0.7,
       },
-    } = c.req.valid("json") as z.infer<typeof TextRequestSchema>;
+    } = c.req.valid("json") as xsschema.Infer<typeof TextRequestSchema>;
 
     const stream = new ReadableStream({
       async start(controller) {
@@ -367,7 +369,7 @@ app.openapi(streamRoute, async (c) => {
       {
         success: false,
         error: error instanceof Error ? error.message : "Failed to initiate text stream",
-      } satisfies z.infer<typeof ErrorSchema>,
+      } satisfies xsschema.Infer<typeof ErrorSchema>,
       500,
     );
   }
@@ -381,7 +383,7 @@ app.openapi(objectRoute, async (c) => {
 
   if (!agent) {
     return c.json(
-      { success: false, error: "Agent not found" } satisfies z.infer<typeof ErrorSchema>,
+      { success: false, error: "Agent not found" } satisfies xsschema.Infer<typeof ErrorSchema>,
       404,
     );
   }
@@ -391,16 +393,19 @@ app.openapi(objectRoute, async (c) => {
       input,
       schema,
       options = {},
-    } = c.req.valid("json") as z.infer<typeof ObjectRequestSchema>;
+    } = c.req.valid("json") as xsschema.Infer<typeof ObjectRequestSchema>;
 
     const response = await agent.generateObject(input, schema, options);
-    return c.json({ success: true, data: response } satisfies z.infer<typeof ObjectResponseSchema>);
+    return c.json(
+      { success: true, data: response } satisfies xsschema.Infer<typeof ObjectResponseSchema>,
+      200,
+    );
   } catch (error) {
     return c.json(
       {
         success: false,
         error: error instanceof Error ? error.message : "Failed to generate object",
-      } satisfies z.infer<typeof ErrorSchema>,
+      } satisfies xsschema.Infer<typeof ErrorSchema>,
       500,
     );
   }
@@ -414,7 +419,7 @@ app.openapi(streamObjectRoute, async (c) => {
 
   if (!agent) {
     return c.json(
-      { success: false, error: "Agent not found" } satisfies z.infer<typeof ErrorSchema>,
+      { success: false, error: "Agent not found" } satisfies xsschema.Infer<typeof ErrorSchema>,
       404,
     );
   }
@@ -424,7 +429,7 @@ app.openapi(streamObjectRoute, async (c) => {
       input,
       schema,
       options = {},
-    } = c.req.valid("json") as z.infer<typeof ObjectRequestSchema>;
+    } = c.req.valid("json") as xsschema.Infer<typeof ObjectRequestSchema>;
 
     const agentStream = await agent.streamObject(input, schema, options);
 
@@ -487,7 +492,7 @@ app.openapi(streamObjectRoute, async (c) => {
       {
         success: false,
         error: error instanceof Error ? error.message : "Failed to initiate object stream",
-      } satisfies z.infer<typeof ErrorSchema>,
+      } satisfies xsschema.Infer<typeof ErrorSchema>,
       500,
     );
   }

packages/core/src/tool/index.ts

@@ -1,6 +1,6 @@
 import { v4 as uuidv4 } from "uuid";
 import type { BaseTool, ToolExecuteOptions, ToolSchema } from "../agent/providers/base/types";
-import type { z } from "zod";
+import type * as xsschema from "xsschema";
 
 // Export ToolManager and related types
 export { ToolManager, ToolStatus, ToolStatusInfo } from "./manager";
@@ -39,7 +39,7 @@ export type ToolOptions<T extends ToolSchema = ToolSchema> = {
   /**
    * Function to execute when the tool is called
    */
-  execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+  execute: (args: xsschema.Infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
 };
 
 /**
@@ -69,7 +69,7 @@ export class Tool<T extends ToolSchema = ToolSchema> /* implements BaseTool<z.in
   /**
    * Function to execute when the tool is called
    */
-  readonly execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+  readonly execute: (args: xsschema.Infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
 
   /**
    * Create a new tool

packages/core/src/tool/reasoning/types.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type * as xsschema from "xsschema";
 import type { ToolExecuteOptions } from "../../agent/providers/base/types";
 
 /**
@@ -30,7 +31,7 @@ export const ReasoningStepSchema = z.object({
 /**
  * TypeScript type inferred from the ReasoningStepSchema.
  */
-export type ReasoningStep = z.infer<typeof ReasoningStepSchema>;
+export type ReasoningStep = xsschema.Infer<typeof ReasoningStepSchema>;
 
 /**
  * Options specific to reasoning tool execution, extending base ToolExecuteOptions.