feat: wip

Author: baseballyama

packages/anthropic-ai/package.json

@@ -25,6 +25,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.40.0",
     "@voltagent/core": "^0.1.22",
+    "xsschema": "0.3.0-beta.2",
     "zod": "3.24.2"
   },
   "devDependencies": {

packages/anthropic-ai/src/index.ts

@@ -13,7 +13,7 @@ import type {
   StreamTextOptions,
   VoltAgentError,
 } from "@voltagent/core";
-import type { z } from "zod";
+import * as xsschema from "xsschema";
 import type {
   AnthropicMessage,
   AnthropicProviderOptions,
@@ -29,7 +29,6 @@ import {
   handleStepFinish,
   processContent,
   processResponseContent,
-  zodToJsonSchema,
 } from "./utils";
 
 export class AnthropicProvider implements LLMProvider<string> {
@@ -80,10 +79,20 @@ export class AnthropicProvider implements LLMProvider<string> {
   }
 
   toTool(tool: BaseTool): AnthropicTool {
+    const jsonSchema = xsschema.toJsonSchemaSync(tool.parameters);
+    if (jsonSchema.type !== "object") {
+      throw new Error("Tool parameters must be an object");
+    }
+
     return {
       name: tool.name,
       description: tool.description,
-      input_schema: zodToJsonSchema(tool.parameters),
+      input_schema: {
+        ...jsonSchema,
+        // Already checked that the type is object above
+        type: "object",
+        properties: jsonSchema.properties ?? {},
+      },
     };
   }
 
@@ -243,11 +252,11 @@ export class AnthropicProvider implements LLMProvider<string> {
     }
   }
 
-  async generateObject<TSchema extends z.ZodType>(
+  async generateObject<TSchema extends xsschema.Schema>(
     options: GenerateObjectOptions<string, TSchema>,
-  ): Promise<ProviderObjectResponse<any, z.infer<TSchema>>> {
+  ): Promise<ProviderObjectResponse<any, xsschema.Infer<TSchema>>> {
     const { temperature = 0.2, maxTokens = 1024, topP, stopSequences } = options.provider || {};
-    const JsonSchema = zodToJsonSchema(options.schema);
+    const JsonSchema = await xsschema.toJsonSchema(options.schema);
     const systemPrompt = `${getSystemMessage(options.messages)}. Response Schema: ${JSON.stringify(JsonSchema)}. You must return the response in valid JSON Format with proper schema, nothing else `;
 
     const anthropicMessages = this.getAnthropicMessages(options.messages);
@@ -283,7 +292,7 @@ export class AnthropicProvider implements LLMProvider<string> {
         throw new Error(`The JSON returned by Anthropic API is not valid \n ${err}`);
       }
 
-      const parsedResult = options.schema.safeParse(parsedObject);
+      const parsedResult = await xsschema.validate(parsedObject, options.schema);
       if (!parsedResult.success) {
         throw new Error(
           `the response doesn't match the specified schema: ${parsedResult.error.message}`,
@@ -320,12 +329,12 @@ export class AnthropicProvider implements LLMProvider<string> {
     }
   }
 
-  async streamObject<TSchema extends z.ZodType>(
+  async streamObject<TSchema extends xsschema.Schema>(
     options: StreamObjectOptions<string, TSchema>,
-  ): Promise<ProviderObjectStreamResponse<any, z.infer<TSchema>>> {
+  ): Promise<ProviderObjectStreamResponse<any, xsschema.Infer<TSchema>>> {
     try {
       const anthropicMessages = this.getAnthropicMessages(options.messages);
-      const JsonSchema = zodToJsonSchema(options.schema);
+      const JsonSchema = await xsschema.toJsonSchema(options.schema);
       const systemPrompt = `${getSystemMessage(options.messages)}. Response Schema: ${JSON.stringify(JsonSchema)}. You must return the response in valid JSON Format with proper schema, nothing else `;
       const { temperature = 0.2, maxTokens = 1024, topP, stopSequences } = options.provider || {};
 
@@ -353,7 +362,7 @@ export class AnthropicProvider implements LLMProvider<string> {
                 // Try to parse partial JSON as it comes in
                 try {
                   const partialObject = JSON.parse(accumulatedText);
-                  const parseResult = options.schema.safeParse(partialObject);
+                  const parseResult = await xsschema.validate(partialObject, options.schema);
 
                   if (parseResult.success) {
                     controller.enqueue(parseResult.data);
@@ -366,7 +375,7 @@ export class AnthropicProvider implements LLMProvider<string> {
               if (chunk.type === "message_stop") {
                 try {
                   const parsedObject = JSON.parse(accumulatedText);
-                  const parsedResult = options.schema.safeParse(parsedObject);
+                  const parsedResult = await xsschema.validate(parsedObject, options.schema);
 
                   if (parsedResult.success) {
                     controller.enqueue(parsedResult.data);

packages/anthropic-ai/src/utils/index.ts

@@ -10,7 +10,6 @@ import type {
   StepWithContent,
   VoltAgentError,
 } from "@voltagent/core";
-import { z } from "zod";
 
 /**
  * Processes text content into a text content block
@@ -171,111 +170,6 @@ export function processContentPart(part: any): ContentBlockParam | null {
   return null;
 }
 
-/**
- * Converts a Zod schema to JSON Schema format that Anthropic expects
- * @param {z.ZodType<any>} schema - The Zod schema to convert
- * @returns {Object} A JSON Schema object with type, properties, and required fields
- * @throws {Error} If the schema is not a Zod object
- */
-export function zodToJsonSchema(schema: z.ZodType<any>): {
-  type: "object";
-  properties: Record<string, unknown>;
-  required?: string[];
-} {
-  // Check if it's a ZodObject by checking for the typeName property
-  if (
-    schema &&
-    typeof schema === "object" &&
-    "_def" in schema &&
-    schema._def &&
-    typeof schema._def === "object" &&
-    "typeName" in schema._def &&
-    schema._def.typeName === "ZodObject"
-  ) {
-    // Use a safer type assertion approach
-    const def = schema._def as unknown as { shape: () => Record<string, z.ZodTypeAny> };
-    const shape = def.shape();
-    const properties: Record<string, unknown> = {};
-    const required: string[] = [];
-
-    for (const [key, value] of Object.entries(shape)) {
-      const fieldSchema = convertZodField(value as z.ZodTypeAny);
-      properties[key] = fieldSchema;
-
-      // Check if the field is required
-      if (!(value instanceof z.ZodOptional)) {
-        required.push(key);
-      }
-    }
-
-    return {
-      type: "object" as const,
-      properties,
-      ...(required.length > 0 ? { required } : {}),
-    };
-  }
-
-  throw new Error("Root schema must be a Zod object");
-}
-
-/**
- * Helper function to create a base schema with type and optional description
- * @param {z.ZodType} field - The Zod field to extract description from
- * @param {string} type - The type string to use
- * @returns {Object} Schema object with type and optional description
- */
-function getBaseSchema(field: z.ZodType, type: string) {
-  return {
-    type,
-    ...(field.description ? { description: field.description } : {}),
-  };
-}
-
-/**
- * Helper function to handle primitive type fields
- * @param {z.ZodTypeAny} field - The Zod field to process
- * @param {string} type - The type string to use
- * @returns {Object} Schema object with type and optional description
- */
-function handlePrimitiveType(field: z.ZodTypeAny, type: string) {
-  return getBaseSchema(field, type);
-}
-
-/**
- * Converts a Zod field to a JSON Schema field
- * @param {z.ZodTypeAny} zodField - The Zod field to convert
- * @returns {any} The JSON Schema representation of the field
- */
-export function convertZodField(zodField: z.ZodTypeAny): any {
-  if (zodField instanceof z.ZodString) {
-    return handlePrimitiveType(zodField, "string");
-  }
-  if (zodField instanceof z.ZodNumber) {
-    return handlePrimitiveType(zodField, "number");
-  }
-  if (zodField instanceof z.ZodBoolean) {
-    return handlePrimitiveType(zodField, "boolean");
-  }
-  if (zodField instanceof z.ZodArray) {
-    return {
-      type: "array",
-      items: convertZodField(zodField.element),
-      ...(zodField.description ? { description: zodField.description } : {}),
-    };
-  }
-  if (zodField instanceof z.ZodEnum) {
-    return {
-      type: "string",
-      enum: zodField._def.values,
-      ...(zodField.description ? { description: zodField.description } : {}),
-    };
-  }
-  if (zodField instanceof z.ZodOptional) {
-    return convertZodField(zodField.unwrap());
-  }
-  return { type: "string" };
-}
-
 /**
  * Creates a response object from Anthropic's response
  * @param {Message} response - The response from Anthropic

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

@@ -191,7 +191,7 @@ export type BaseMessage = {
 };
 
 // Schema types
-export type ToolSchema = xsschema.Schema;
+export type ToolSchema = xsschema.JsonSchema;
 
 // Base tool types
 export type ToolExecuteOptions = {

packages/core/src/mcp/client/index.ts

@@ -11,8 +11,7 @@ import {
   CallToolResultSchema,
   ListResourcesResultSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import type * as z from "zod";
-import { convertJsonSchemaToZod } from "zod-from-json-schema";
+import * as xsschema from "xsschema";
 import devLogger from "../../utils/internal/dev-logger";
 import { type Tool, createTool } from "../../tool";
 import type {
@@ -192,16 +191,14 @@ export class MCPClient extends EventEmitter {
         inputSchema: unknown;
       }[]) {
         try {
-          const zodSchema = convertJsonSchemaToZod(
-            toolDef.inputSchema as Record<string, unknown>,
-          ) as unknown as z.ZodType;
+          const jsonSchema = await xsschema.toJsonSchema(toolDef.inputSchema as xsschema.Schema);
           const namespacedToolName = `${this.clientInfo.name}_${toolDef.name}`; // Use original separator
 
           const agentTool = createTool({
             name: namespacedToolName,
             description: toolDef.description || `Executes the remote tool: ${toolDef.name}`,
-            parameters: zodSchema,
-            execute: async (args: Record<string, unknown>): Promise<unknown> => {
+            parameters: jsonSchema,
+            execute: async (args: xsschema.JsonSchema): Promise<unknown> => {
               try {
                 const result = await this.callTool({
                   // Use original method name

packages/core/src/mcp/types.ts

@@ -1,5 +1,6 @@
 import type { ClientCapabilities } from "@modelcontextprotocol/sdk/types.js";
 import type { Tool } from "../tool";
+import type * as xsschema from "xsschema";
 
 /**
  * Client information for MCP
@@ -170,7 +171,7 @@ export type MCPToolCall = {
   /**
    * Arguments to pass to the tool
    */
-  arguments: Record<string, unknown>;
+  arguments: xsschema.JsonSchema;
 };
 
 /**

packages/core/src/tool/index.ts

@@ -1,7 +1,6 @@
 import { v4 as uuidv4 } from "uuid";
 import type { BaseTool, ToolExecuteOptions, ToolSchema } from "../agent/providers/base/types";
 import devLogger from "../utils/internal/dev-logger";
-import type * as xsschema from "xsschema";
 
 // Export ToolManager and related types
 export { ToolManager, ToolStatus, ToolStatusInfo } from "./manager";
@@ -40,7 +39,7 @@ export type ToolOptions<T extends ToolSchema = ToolSchema> = {
   /**
    * Function to execute when the tool is called
    */
-  execute: (args: xsschema.Infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+  execute: (args: T, options?: ToolExecuteOptions) => Promise<unknown>;
 };
 
 /**
@@ -70,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: xsschema.Infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+  readonly execute: (args: T, options?: ToolExecuteOptions) => Promise<unknown>;
 
   /**
    * Create a new tool