@tanstack/ai 0.1.0 → 0.2.0

package/src/activities/chat/tools/tool-calls.ts

@@ -1,20 +1,11 @@
+import { isStandardSchema, parseWithStandardSchema } from './schema-converter'
 import type {
   DoneStreamChunk,
   ModelMessage,
-  SchemaInput,
   Tool,
   ToolCall,
   ToolResultStreamChunk,
 } from '../../../types'
-import type { z } from 'zod'
-
-/**
- * Check if a value is a Zod schema by looking for Zod-specific internals.
- */
-function isZodSchema(schema: SchemaInput | undefined): schema is z.ZodType {
-  if (!schema) return false
-  return '_zod' in schema && typeof (schema as any)._zod === 'object'
-}
 
 /**
  * Manages tool call accumulation and execution for the chat() method's automatic tool execution loop.
@@ -131,7 +122,7 @@ export class ToolCallManager {
       if (tool?.execute) {
         try {
           // Parse arguments
-          let args: any
+          let args: unknown
           try {
             args = JSON.parse(toolCall.function.arguments)
           } catch (parseError) {
@@ -140,13 +131,17 @@ export class ToolCallManager {
             )
           }
 
-          // Validate input against inputSchema (only for Zod schemas)
-          if (tool.inputSchema && isZodSchema(tool.inputSchema)) {
+          // Validate input against inputSchema (for Standard Schema compliant schemas)
+          if (tool.inputSchema && isStandardSchema(tool.inputSchema)) {
             try {
-              args = tool.inputSchema.parse(args)
-            } catch (validationError: any) {
+              args = parseWithStandardSchema(tool.inputSchema, args)
+            } catch (validationError: unknown) {
+              const message =
+                validationError instanceof Error
+                  ? validationError.message
+                  : 'Validation failed'
               throw new Error(
-                `Input validation failed for tool ${tool.name}: ${validationError.message}`,
+                `Input validation failed for tool ${tool.name}: ${message}`,
               )
             }
           }
@@ -154,27 +149,33 @@ export class ToolCallManager {
           // Execute the tool
           let result = await tool.execute(args)
 
-          // Validate output against outputSchema if provided (only for Zod schemas)
+          // Validate output against outputSchema if provided (for Standard Schema compliant schemas)
           if (
             tool.outputSchema &&
-            isZodSchema(tool.outputSchema) &&
+            isStandardSchema(tool.outputSchema) &&
             result !== undefined &&
             result !== null
           ) {
             try {
-              result = tool.outputSchema.parse(result)
-            } catch (validationError: any) {
+              result = parseWithStandardSchema(tool.outputSchema, result)
+            } catch (validationError: unknown) {
+              const message =
+                validationError instanceof Error
+                  ? validationError.message
+                  : 'Validation failed'
               throw new Error(
-                `Output validation failed for tool ${tool.name}: ${validationError.message}`,
+                `Output validation failed for tool ${tool.name}: ${message}`,
               )
             }
           }
 
           toolResultContent =
             typeof result === 'string' ? result : JSON.stringify(result)
-        } catch (error: any) {
+        } catch (error: unknown) {
           // If tool execution fails, add error message
-          toolResultContent = `Error executing tool: ${error.message}`
+          const message =
+            error instanceof Error ? error.message : 'Unknown error'
+          toolResultContent = `Error executing tool: ${message}`
         }
       } else {
         // Tool doesn't have execute function, add placeholder
@@ -286,7 +287,7 @@ export async function executeToolCalls(
     }
 
     // Parse arguments, throwing error if invalid JSON
-    let input: any = {}
+    let input: unknown = {}
     const argsStr = toolCall.function.arguments.trim() || '{}'
     if (argsStr) {
       try {
@@ -297,16 +298,20 @@ export async function executeToolCalls(
       }
     }
 
-    // Validate input against inputSchema (only for Zod schemas)
-    if (tool.inputSchema && isZodSchema(tool.inputSchema)) {
+    // Validate input against inputSchema (for Standard Schema compliant schemas)
+    if (tool.inputSchema && isStandardSchema(tool.inputSchema)) {
       try {
-        input = tool.inputSchema.parse(input)
-      } catch (validationError: any) {
+        input = parseWithStandardSchema(tool.inputSchema, input)
+      } catch (validationError: unknown) {
+        const message =
+          validationError instanceof Error
+            ? validationError.message
+            : 'Validation failed'
         results.push({
           toolCallId: toolCall.id,
           toolName,
           result: {
-            error: `Input validation failed for tool ${tool.name}: ${validationError.message}`,
+            error: `Input validation failed for tool ${tool.name}: ${message}`,
           },
           state: 'output-error',
         })
@@ -393,21 +398,14 @@ export async function executeToolCalls(
             let result = await tool.execute(input)
             const duration = Date.now() - startTime
 
-            // Validate output against outputSchema if provided (only for Zod schemas)
+            // Validate output against outputSchema if provided (for Standard Schema compliant schemas)
             if (
               tool.outputSchema &&
-              isZodSchema(tool.outputSchema) &&
+              isStandardSchema(tool.outputSchema) &&
               result !== undefined &&
               result !== null
             ) {
-              const parsed = tool.outputSchema.safeParse(result)
-              if (parsed.success) {
-                result = parsed.data
-              } else {
-                throw new Error(
-                  `Output validation failed for tool ${tool.name}: ${parsed.error.message}`,
-                )
-              }
+              result = parseWithStandardSchema(tool.outputSchema, result)
             }
 
             results.push({
@@ -419,12 +417,14 @@ export async function executeToolCalls(
                   : result || null,
               duration,
             })
-          } catch (error: any) {
+          } catch (error: unknown) {
             const duration = Date.now() - startTime
+            const message =
+              error instanceof Error ? error.message : 'Unknown error'
             results.push({
               toolCallId: toolCall.id,
               toolName,
-              result: { error: error.message },
+              result: { error: message },
               state: 'output-error',
               duration,
             })
@@ -456,21 +456,14 @@ export async function executeToolCalls(
       let result = await tool.execute(input)
       const duration = Date.now() - startTime
 
-      // Validate output against outputSchema if provided (only for Zod schemas)
+      // Validate output against outputSchema if provided (for Standard Schema compliant schemas)
       if (
         tool.outputSchema &&
-        isZodSchema(tool.outputSchema) &&
+        isStandardSchema(tool.outputSchema) &&
         result !== undefined &&
         result !== null
       ) {
-        const parsed = tool.outputSchema.safeParse(result)
-        if (parsed.success) {
-          result = parsed.data
-        } else {
-          throw new Error(
-            `Output validation failed for tool ${tool.name}: ${parsed.error.message}`,
-          )
-        }
+        result = parseWithStandardSchema(tool.outputSchema, result)
       }
 
       results.push({
@@ -480,12 +473,13 @@ export async function executeToolCalls(
           typeof result === 'string' ? JSON.parse(result) : result || null,
         duration,
       })
-    } catch (error: any) {
+    } catch (error: unknown) {
       const duration = Date.now() - startTime
+      const message = error instanceof Error ? error.message : 'Unknown error'
       results.push({
         toolCallId: toolCall.id,
         toolName,
-        result: { error: error.message },
+        result: { error: message },
         state: 'output-error',
         duration,
       })

package/src/activities/chat/tools/tool-definition.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod'
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec'
 import type {
   InferSchemaType,
   JSONSchema,
@@ -10,8 +10,8 @@ import type {
  * Marker type for server-side tools
  */
 export interface ServerTool<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > extends Tool<TInput, TOutput, TName> {
   __toolSide: 'server'
@@ -21,8 +21,8 @@ export interface ServerTool<
  * Marker type for client-side tools
  */
 export interface ClientTool<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > {
   __toolSide: 'client'
@@ -31,7 +31,7 @@ export interface ClientTool<
   inputSchema?: TInput
   outputSchema?: TOutput
   needsApproval?: boolean
-  metadata?: Record<string, any>
+  metadata?: Record<string, unknown>
   execute?: (
     args: InferSchemaType<TInput>,
   ) => Promise<InferSchemaType<TOutput>> | InferSchemaType<TOutput>
@@ -41,8 +41,8 @@ export interface ClientTool<
  * Tool definition that can be used directly or instantiated for server/client
  */
 export interface ToolDefinitionInstance<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > extends Tool<TInput, TOutput, TName> {
   __toolSide: 'definition'
@@ -52,8 +52,8 @@ export interface ToolDefinitionInstance<
  * Union type for any kind of client-side tool (client tool or definition)
  */
 export type AnyClientTool =
-  | ClientTool<any, any>
-  | ToolDefinitionInstance<any, any>
+  | ClientTool<SchemaInput, SchemaInput>
+  | ToolDefinitionInstance<SchemaInput, SchemaInput>
 
 /**
  * Extract the tool name as a literal type
@@ -61,33 +61,33 @@ export type AnyClientTool =
 export type InferToolName<T> = T extends { name: infer N } ? N : never
 
 /**
- * Extract the input type from a tool (inferred from Zod schema, or `any` for JSONSchema)
+ * Extract the input type from a tool (inferred from Standard JSON Schema, or `unknown` for plain JSONSchema)
  */
 export type InferToolInput<T> = T extends { inputSchema?: infer TInput }
-  ? TInput extends z.ZodType
-    ? z.infer<TInput>
+  ? TInput extends StandardJSONSchemaV1<infer TInferred, unknown>
+    ? TInferred
     : TInput extends JSONSchema
-      ? any
-      : any
-  : any
+      ? unknown
+      : unknown
+  : unknown
 
 /**
- * Extract the output type from a tool (inferred from Zod schema, or `any` for JSONSchema)
+ * Extract the output type from a tool (inferred from Standard JSON Schema, or `unknown` for plain JSONSchema)
  */
 export type InferToolOutput<T> = T extends { outputSchema?: infer TOutput }
-  ? TOutput extends z.ZodType
-    ? z.infer<TOutput>
+  ? TOutput extends StandardJSONSchemaV1<infer TInferred, unknown>
+    ? TInferred
     : TOutput extends JSONSchema
-      ? any
-      : any
-  : any
+      ? unknown
+      : unknown
+  : unknown
 
 /**
  * Tool definition configuration
  */
 export interface ToolDefinitionConfig<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > {
   name: TName
@@ -95,15 +95,15 @@ export interface ToolDefinitionConfig<
   inputSchema?: TInput
   outputSchema?: TOutput
   needsApproval?: boolean
-  metadata?: Record<string, any>
+  metadata?: Record<string, unknown>
 }
 
 /**
  * Tool definition builder that allows creating server or client tools from a shared definition
  */
 export interface ToolDefinition<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > extends ToolDefinitionInstance<TInput, TOutput, TName> {
   /**
@@ -133,11 +133,15 @@ export interface ToolDefinition<
  * 2. Instantiated as a server tool with .server()
  * 3. Instantiated as a client tool with .client()
  *
+ * Supports any Standard JSON Schema compliant library (Zod v4+, ArkType, Valibot, etc.)
+ * or plain JSON Schema objects.
+ *
  * @example
  * ```typescript
  * import { toolDefinition } from '@tanstack/ai';
  * import { z } from 'zod';
  *
+ * // Using Zod (natively supports Standard JSON Schema)
  * const addToCartTool = toolDefinition({
  *   name: 'addToCart',
  *   description: 'Add a guitar to the shopping cart (requires approval)',
@@ -177,8 +181,8 @@ export interface ToolDefinition<
  * ```
  */
 export function toolDefinition<
-  TInput extends SchemaInput = z.ZodAny,
-  TOutput extends SchemaInput = z.ZodAny,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 >(
   config: ToolDefinitionConfig<TInput, TOutput, TName>,

package/src/index.ts

@@ -47,7 +47,9 @@ export {
   type InferToolInput,
   type InferToolOutput,
 } from './activities/chat/tools/tool-definition'
-export { convertZodToJsonSchema } from './activities/chat/tools/zod-converter'
+
+// Schema conversion (Standard JSON Schema compliant)
+export { convertSchemaToJsonSchema } from './activities/chat/tools/schema-converter'
 
 // Stream utilities
 export {

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { z } from 'zod'
+import type { StandardJSONSchemaV1 } from '@standard-schema/spec'
 
 /**
  * Tool call states - track the lifecycle of a tool call
@@ -20,17 +20,17 @@ export type ToolResultState =
 
 /**
  * JSON Schema type for defining tool input/output schemas as raw JSON Schema objects.
- * This allows tools to be defined without Zod when you have JSON Schema definitions available.
+ * This allows tools to be defined without schema libraries when you have JSON Schema definitions available.
  */
 export interface JSONSchema {
   type?: string | Array<string>
   properties?: Record<string, JSONSchema>
   items?: JSONSchema | Array<JSONSchema>
   required?: Array<string>
-  enum?: Array<any>
-  const?: any
+  enum?: Array<unknown>
+  const?: unknown
   description?: string
-  default?: any
+  default?: unknown
   $ref?: string
   $defs?: Record<string, JSONSchema>
   definitions?: Record<string, JSONSchema>
@@ -59,21 +59,30 @@ export interface JSONSchema {
   minProperties?: number
   maxProperties?: number
   title?: string
-  examples?: Array<any>
-  [key: string]: any // Allow additional properties for extensibility
+  examples?: Array<unknown>
+  [key: string]: unknown // Allow additional properties for extensibility
 }
 
 /**
- * Union type for schema input - can be either a Zod schema or a JSONSchema object.
+ * Union type for schema input - can be any Standard JSON Schema compliant schema or a plain JSONSchema object.
+ *
+ * Standard JSON Schema compliant libraries include:
+ * - Zod v4.2+ (natively supports StandardJSONSchemaV1)
+ * - ArkType v2.1.28+ (natively supports StandardJSONSchemaV1)
+ * - Valibot v1.2+ (via `toStandardJsonSchema()` from `@valibot/to-json-schema`)
+ *
+ * @see https://standardschema.dev/json-schema
  */
-export type SchemaInput = z.ZodType | JSONSchema
+
+export type SchemaInput = StandardJSONSchemaV1<any, any> | JSONSchema
 
 /**
  * Infer the TypeScript type from a schema.
- * For Zod schemas, uses z.infer to get the proper type.
- * For JSONSchema, returns `any` since we can't infer types from JSON Schema at compile time.
+ * For Standard JSON Schema compliant schemas, extracts the input type.
+ * For plain JSONSchema, returns `any` since we can't infer types from JSON Schema at compile time.
  */
-export type InferSchemaType<T> = T extends z.ZodType ? z.infer<T> : any
+export type InferSchemaType<T> =
+  T extends StandardJSONSchemaV1<infer TInput, unknown> ? TInput : unknown
 
 export interface ToolCall {
   id: string
@@ -309,14 +318,16 @@ export type ConstrainedModelMessage<
  * Tools allow the model to interact with external systems, APIs, or perform computations.
  * The model will decide when to call tools based on the user's request and the tool descriptions.
  *
- * Tools can use either Zod schemas or JSON Schema objects for runtime validation and type safety.
+ * Tools can use any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.)
+ * or plain JSON Schema objects for runtime validation and type safety.
  *
  * @see https://platform.openai.com/docs/guides/function-calling
  * @see https://docs.anthropic.com/claude/docs/tool-use
+ * @see https://standardschema.dev/json-schema
  */
 export interface Tool<
-  TInput extends SchemaInput = z.ZodType,
-  TOutput extends SchemaInput = z.ZodType,
+  TInput extends SchemaInput = SchemaInput,
+  TOutput extends SchemaInput = SchemaInput,
   TName extends string = string,
 > {
   /**
@@ -342,16 +353,16 @@ export interface Tool<
   /**
    * Schema describing the tool's input parameters.
    *
-   * Can be either a Zod schema or a JSON Schema object.
+   * Can be any Standard JSON Schema compliant schema (Zod, ArkType, Valibot, etc.) or a plain JSON Schema object.
    * Defines the structure and types of arguments the tool accepts.
    * The model will generate arguments matching this schema.
-   * Zod schemas are converted to JSON Schema for LLM providers.
+   * Standard JSON Schema compliant schemas are converted to JSON Schema for LLM providers.
    *
-   * @see https://zod.dev/
+   * @see https://standardschema.dev/json-schema
    * @see https://json-schema.org/
    *
    * @example
-   * // Using Zod schema
+   * // Using Zod v4+ schema (natively supports Standard JSON Schema)
    * import { z } from 'zod';
    * z.object({
    *   location: z.string().describe("City name or coordinates"),
@@ -359,7 +370,15 @@ export interface Tool<
    * })
    *
    * @example
-   * // Using JSON Schema
+   * // Using ArkType (natively supports Standard JSON Schema)
+   * import { type } from 'arktype';
+   * type({
+   *   location: 'string',
+   *   unit: "'celsius' | 'fahrenheit'"
+   * })
+   *
+   * @example
+   * // Using plain JSON Schema
    * {
    *   type: 'object',
    *   properties: {
@@ -374,15 +393,16 @@ export interface Tool<
   /**
    * Optional schema for validating tool output.
    *
-   * Can be either a Zod schema or a JSON Schema object.
-   * If provided with a Zod schema, tool results will be validated against this schema before
-   * being sent back to the model. This catches bugs in tool implementations
-   * and ensures consistent output formatting.
+   * Can be any Standard JSON Schema compliant schema or a plain JSON Schema object.
+   * If provided with a Standard Schema compliant schema, tool results will be validated
+   * against this schema before being sent back to the model. This catches bugs in tool
+   * implementations and ensures consistent output formatting.
    *
    * Note: This is client-side validation only - not sent to LLM providers.
-   * Note: JSON Schema output validation is not performed at runtime.
+   * Note: Plain JSON Schema output validation is not performed at runtime.
    *
    * @example
+   * // Using Zod
    * z.object({
    *   temperature: z.number(),
    *   conditions: z.string(),
@@ -601,12 +621,13 @@ export interface TextOptions<
   request?: Request | RequestInit
 
   /**
-   * Zod schema for structured output.
+   * Schema for structured output.
    * When provided, the adapter should use the provider's native structured output API
    * to ensure the response conforms to this schema.
    * The schema will be converted to JSON Schema format before being sent to the provider.
+   * Supports any Standard JSON Schema compliant library (Zod, ArkType, Valibot, etc.).
    */
-  outputSchema?: z.ZodType
+  outputSchema?: SchemaInput
   /**
    * Conversation ID for correlating client and server-side devtools events.
    * When provided, server-side events will be linked to the client conversation in devtools.

package/dist/esm/activities/chat/tools/zod-converter.d.ts

@@ -1,69 +0,0 @@
-import { SchemaInput } from '../../../types.js';
-/**
- * Options for schema conversion
- */
-export interface ConvertSchemaOptions {
-    /**
-     * When true, transforms the schema to be compatible with OpenAI's structured output requirements:
-     * - All properties are added to the `required` array
-     * - Optional fields get null added to their type union
-     * - additionalProperties is set to false for all objects
-     *
-     * @default false
-     */
-    forStructuredOutput?: boolean;
-}
-/**
- * Converts a schema (Zod or JSONSchema) to JSON Schema format compatible with LLM providers.
- * If the input is already a JSONSchema object, it is returned as-is.
- * If the input is a Zod schema, it is converted to JSON Schema.
- *
- * @param schema - Zod schema or JSONSchema object to convert
- * @param options - Conversion options
- * @returns JSON Schema object that can be sent to LLM providers
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- *
- * // Using Zod schema
- * const zodSchema = z.object({
- *   location: z.string().describe('City name'),
- *   unit: z.enum(['celsius', 'fahrenheit']).optional()
- * });
- *
- * const jsonSchema = convertZodToJsonSchema(zodSchema);
- * // Returns:
- * // {
- * //   type: 'object',
- * //   properties: {
- * //     location: { type: 'string', description: 'City name' },
- * //     unit: { type: 'string', enum: ['celsius', 'fahrenheit'] }
- * //   },
- * //   required: ['location']
- * // }
- *
- * // For OpenAI structured output (all fields required, optional fields nullable)
- * const structuredSchema = convertZodToJsonSchema(zodSchema, { forStructuredOutput: true });
- * // Returns:
- * // {
- * //   type: 'object',
- * //   properties: {
- * //     location: { type: 'string', description: 'City name' },
- * //     unit: { type: ['string', 'null'], enum: ['celsius', 'fahrenheit'] }
- * //   },
- * //   required: ['location', 'unit'],
- * //   additionalProperties: false
- * // }
- *
- * // Using JSONSchema directly (passes through unchanged)
- * const rawSchema = {
- *   type: 'object',
- *   properties: { location: { type: 'string' } },
- *   required: ['location']
- * };
- * const result = convertZodToJsonSchema(rawSchema);
- * // Returns the same object
- * ```
- */
-export declare function convertZodToJsonSchema(schema: SchemaInput | undefined, options?: ConvertSchemaOptions): Record<string, any> | undefined;