ai-tool-adapter 1.0.0 → 1.0.1

package/dist/adapters/openai.test.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Tests for OpenAI adapter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const openai_1 = require("./openai");
+(0, vitest_1.describe)('openaiAdapter', () => {
+    (0, vitest_1.it)('should convert a basic tool with required params', () => {
+        const tool = {
+            name: 'get_weather',
+            description: 'Get current weather for a location',
+            params: {
+                location: {
+                    type: 'string',
+                    description: 'City name',
+                    required: true,
+                },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result).toEqual({
+            type: 'function',
+            function: {
+                name: 'get_weather',
+                description: 'Get current weather for a location',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        location: {
+                            type: 'string',
+                            description: 'City name',
+                        },
+                    },
+                    required: ['location'],
+                },
+            },
+        });
+    });
+    (0, vitest_1.it)('should handle enum values', () => {
+        const tool = {
+            name: 'set_temperature',
+            description: 'Set temperature unit',
+            params: {
+                unit: {
+                    type: 'string',
+                    enum: ['celsius', 'fahrenheit', 'kelvin'],
+                    required: true,
+                },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result.function.parameters.properties.unit).toEqual({
+            type: 'string',
+            enum: ['celsius', 'fahrenheit', 'kelvin'],
+        });
+    });
+    (0, vitest_1.it)('should handle array types with items', () => {
+        const tool = {
+            name: 'process_items',
+            description: 'Process a list of items',
+            params: {
+                items: {
+                    type: 'array',
+                    description: 'List of items',
+                    items: { type: 'string' },
+                    required: true,
+                },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result.function.parameters.properties.items).toEqual({
+            type: 'array',
+            description: 'List of items',
+            items: { type: 'string' },
+        });
+    });
+    (0, vitest_1.it)('should handle default values', () => {
+        const tool = {
+            name: 'paginate',
+            description: 'Get paginated results',
+            params: {
+                page: {
+                    type: 'number',
+                    default: 1,
+                },
+                limit: {
+                    type: 'number',
+                    default: 10,
+                },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result.function.parameters.properties.page).toEqual({
+            type: 'number',
+            default: 1,
+        });
+        (0, vitest_1.expect)(result.function.parameters.properties.limit).toEqual({
+            type: 'number',
+            default: 10,
+        });
+    });
+    (0, vitest_1.it)('should handle mixed required and optional params', () => {
+        const tool = {
+            name: 'search',
+            description: 'Search for items',
+            params: {
+                query: {
+                    type: 'string',
+                    description: 'Search query',
+                    required: true,
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Result limit',
+                    default: 10,
+                },
+                exact: {
+                    type: 'boolean',
+                    description: 'Exact match',
+                },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result.function.parameters.required).toEqual(['query']);
+        (0, vitest_1.expect)(result.function.parameters.properties).toHaveProperty('query');
+        (0, vitest_1.expect)(result.function.parameters.properties).toHaveProperty('limit');
+        (0, vitest_1.expect)(result.function.parameters.properties).toHaveProperty('exact');
+    });
+    (0, vitest_1.it)('should handle empty params', () => {
+        const tool = {
+            name: 'get_status',
+            description: 'Get current status',
+            params: {},
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result.function.parameters).toEqual({
+            type: 'object',
+            properties: {},
+            required: [],
+        });
+    });
+    (0, vitest_1.it)('should use lowercase type names', () => {
+        const tool = {
+            name: 'test_types',
+            description: 'Test all types',
+            params: {
+                str: { type: 'string' },
+                num: { type: 'number' },
+                bool: { type: 'boolean' },
+                arr: { type: 'array', items: { type: 'string' } },
+                obj: { type: 'object' },
+            },
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        const props = result.function.parameters.properties;
+        (0, vitest_1.expect)(props.str.type).toBe('string');
+        (0, vitest_1.expect)(props.num.type).toBe('number');
+        (0, vitest_1.expect)(props.bool.type).toBe('boolean');
+        (0, vitest_1.expect)(props.arr.type).toBe('array');
+        (0, vitest_1.expect)(props.obj.type).toBe('object');
+    });
+    (0, vitest_1.it)('should wrap in function object', () => {
+        const tool = {
+            name: 'test',
+            description: 'Test tool',
+            params: {},
+        };
+        const result = (0, openai_1.openaiAdapter)(tool);
+        (0, vitest_1.expect)(result).toHaveProperty('type', 'function');
+        (0, vitest_1.expect)(result).toHaveProperty('function');
+        (0, vitest_1.expect)(result.function).toHaveProperty('name');
+        (0, vitest_1.expect)(result.function).toHaveProperty('description');
+        (0, vitest_1.expect)(result.function).toHaveProperty('parameters');
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Universal AI Tool Schema Adapter
+ *
+ * Write tool definitions once, convert to any LLM provider format.
+ * Eliminates duplication and provider lock-in.
+ *
+ * @example
+ * ```typescript
+ * import { adapt } from 'ai-tool-adapter';
+ *
+ * const tool = {
+ *   name: 'get_weather',
+ *   description: 'Get current weather for a location',
+ *   params: {
+ *     location: { type: 'string', required: true },
+ *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+ *   }
+ * };
+ *
+ * const openaiTool = adapt(tool, 'openai');
+ * const anthropicTool = adapt(tool, 'anthropic');
+ * ```
+ */
+import { UniversalTool, Provider } from './types';
+/**
+ * Convert a universal tool definition to a specific provider's format
+ *
+ * @param tool - Universal tool definition
+ * @param provider - Target AI provider
+ * @returns Provider-specific tool format
+ * @throws {Error} If provider is not supported
+ *
+ * @example
+ * ```typescript
+ * const tool = {
+ *   name: 'calculate',
+ *   description: 'Perform arithmetic calculation',
+ *   params: {
+ *     operation: { type: 'string', required: true, enum: ['add', 'subtract'] },
+ *     a: { type: 'number', required: true },
+ *     b: { type: 'number', required: true }
+ *   }
+ * };
+ *
+ * const openaiTool = adapt(tool, 'openai');
+ * ```
+ */
+export declare function adapt(tool: UniversalTool, provider: Provider): unknown;
+/**
+ * Convert multiple universal tool definitions to a specific provider's format
+ *
+ * @param tools - Array of universal tool definitions
+ * @param provider - Target AI provider
+ * @returns Array of provider-specific tool formats
+ * @throws {Error} If provider is not supported
+ *
+ * @example
+ * ```typescript
+ * const tools = [
+ *   { name: 'get_weather', description: 'Get weather', params: {...} },
+ *   { name: 'get_time', description: 'Get time', params: {...} }
+ * ];
+ *
+ * const openaiTools = adaptAll(tools, 'openai');
+ * ```
+ */
+export declare function adaptAll(tools: UniversalTool[], provider: Provider): unknown[];
+/**
+ * Get list of all supported AI providers
+ *
+ * @returns Array of supported provider names
+ *
+ * @example
+ * ```typescript
+ * const providers = getProviders();
+ * console.log(providers); // ['openai', 'anthropic', 'gemini', 'mistral']
+ * ```
+ */
+export declare function getProviders(): Provider[];
+/**
+ * Export types for TypeScript consumers
+ */
+export type { UniversalTool, ToolParam, Provider, ParamType } from './types';

package/dist/index.js

@@ -1 +1,106 @@
 "use strict";
+/**
+ * Universal AI Tool Schema Adapter
+ *
+ * Write tool definitions once, convert to any LLM provider format.
+ * Eliminates duplication and provider lock-in.
+ *
+ * @example
+ * ```typescript
+ * import { adapt } from 'ai-tool-adapter';
+ *
+ * const tool = {
+ *   name: 'get_weather',
+ *   description: 'Get current weather for a location',
+ *   params: {
+ *     location: { type: 'string', required: true },
+ *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+ *   }
+ * };
+ *
+ * const openaiTool = adapt(tool, 'openai');
+ * const anthropicTool = adapt(tool, 'anthropic');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapt = adapt;
+exports.adaptAll = adaptAll;
+exports.getProviders = getProviders;
+const openai_1 = require("./adapters/openai");
+const anthropic_1 = require("./adapters/anthropic");
+const gemini_1 = require("./adapters/gemini");
+const mistral_1 = require("./adapters/mistral");
+/**
+ * Adapter registry mapping provider names to their adapter functions
+ */
+const adapters = {
+    openai: openai_1.openaiAdapter,
+    anthropic: anthropic_1.anthropicAdapter,
+    gemini: gemini_1.geminiAdapter,
+    mistral: mistral_1.mistralAdapter,
+};
+/**
+ * Convert a universal tool definition to a specific provider's format
+ *
+ * @param tool - Universal tool definition
+ * @param provider - Target AI provider
+ * @returns Provider-specific tool format
+ * @throws {Error} If provider is not supported
+ *
+ * @example
+ * ```typescript
+ * const tool = {
+ *   name: 'calculate',
+ *   description: 'Perform arithmetic calculation',
+ *   params: {
+ *     operation: { type: 'string', required: true, enum: ['add', 'subtract'] },
+ *     a: { type: 'number', required: true },
+ *     b: { type: 'number', required: true }
+ *   }
+ * };
+ *
+ * const openaiTool = adapt(tool, 'openai');
+ * ```
+ */
+function adapt(tool, provider) {
+    const adapter = adapters[provider];
+    if (!adapter) {
+        throw new Error(`Unknown provider: ${provider}. Supported providers: ${getProviders().join(', ')}`);
+    }
+    return adapter(tool);
+}
+/**
+ * Convert multiple universal tool definitions to a specific provider's format
+ *
+ * @param tools - Array of universal tool definitions
+ * @param provider - Target AI provider
+ * @returns Array of provider-specific tool formats
+ * @throws {Error} If provider is not supported
+ *
+ * @example
+ * ```typescript
+ * const tools = [
+ *   { name: 'get_weather', description: 'Get weather', params: {...} },
+ *   { name: 'get_time', description: 'Get time', params: {...} }
+ * ];
+ *
+ * const openaiTools = adaptAll(tools, 'openai');
+ * ```
+ */
+function adaptAll(tools, provider) {
+    return tools.map((tool) => adapt(tool, provider));
+}
+/**
+ * Get list of all supported AI providers
+ *
+ * @returns Array of supported provider names
+ *
+ * @example
+ * ```typescript
+ * const providers = getProviders();
+ * console.log(providers); // ['openai', 'anthropic', 'gemini', 'mistral']
+ * ```
+ */
+function getProviders() {
+    return Object.keys(adapters);
+}

package/dist/index.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Integration tests for the public API
+ */
+export {};

package/dist/index.test.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Integration tests for the public API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("./index");
+(0, vitest_1.describe)('adapt', () => {
+    const sampleTool = {
+        name: 'get_weather',
+        description: 'Get current weather for a location',
+        params: {
+            location: {
+                type: 'string',
+                description: 'City name',
+                required: true,
+            },
+            units: {
+                type: 'string',
+                enum: ['celsius', 'fahrenheit'],
+            },
+        },
+    };
+    (0, vitest_1.it)('should adapt tool to OpenAI format', () => {
+        const result = (0, index_1.adapt)(sampleTool, 'openai');
+        (0, vitest_1.expect)(result).toHaveProperty('type', 'function');
+        (0, vitest_1.expect)(result).toHaveProperty('function');
+    });
+    (0, vitest_1.it)('should adapt tool to Anthropic format', () => {
+        const result = (0, index_1.adapt)(sampleTool, 'anthropic');
+        (0, vitest_1.expect)(result).toHaveProperty('name', 'get_weather');
+        (0, vitest_1.expect)(result).toHaveProperty('input_schema');
+        (0, vitest_1.expect)(result).not.toHaveProperty('type');
+    });
+    (0, vitest_1.it)('should adapt tool to Gemini format', () => {
+        const result = (0, index_1.adapt)(sampleTool, 'gemini');
+        (0, vitest_1.expect)(result).toHaveProperty('name', 'get_weather');
+        (0, vitest_1.expect)(result).toHaveProperty('parameters');
+        (0, vitest_1.expect)(result).not.toHaveProperty('type');
+    });
+    (0, vitest_1.it)('should adapt tool to Mistral format', () => {
+        const result = (0, index_1.adapt)(sampleTool, 'mistral');
+        (0, vitest_1.expect)(result).toHaveProperty('type', 'function');
+        (0, vitest_1.expect)(result).toHaveProperty('function');
+    });
+    (0, vitest_1.it)('should throw error for unknown provider', () => {
+        (0, vitest_1.expect)(() => {
+            (0, index_1.adapt)(sampleTool, 'unknown');
+        }).toThrow('Unknown provider: unknown');
+    });
+    (0, vitest_1.it)('should include list of supported providers in error message', () => {
+        (0, vitest_1.expect)(() => {
+            (0, index_1.adapt)(sampleTool, 'invalid');
+        }).toThrow(/openai.*anthropic.*gemini.*mistral/);
+    });
+});
+(0, vitest_1.describe)('adaptAll', () => {
+    const tools = [
+        {
+            name: 'get_weather',
+            description: 'Get weather',
+            params: {
+                location: { type: 'string', required: true },
+            },
+        },
+        {
+            name: 'get_time',
+            description: 'Get current time',
+            params: {
+                timezone: { type: 'string' },
+            },
+        },
+        {
+            name: 'calculate',
+            description: 'Perform calculation',
+            params: {
+                operation: { type: 'string', enum: ['add', 'subtract'], required: true },
+                a: { type: 'number', required: true },
+                b: { type: 'number', required: true },
+            },
+        },
+    ];
+    (0, vitest_1.it)('should adapt multiple tools to OpenAI format', () => {
+        const results = (0, index_1.adaptAll)(tools, 'openai');
+        (0, vitest_1.expect)(results).toHaveLength(3);
+        results.forEach((result) => {
+            (0, vitest_1.expect)(result).toHaveProperty('type', 'function');
+            (0, vitest_1.expect)(result).toHaveProperty('function');
+        });
+    });
+    (0, vitest_1.it)('should adapt multiple tools to Anthropic format', () => {
+        const results = (0, index_1.adaptAll)(tools, 'anthropic');
+        (0, vitest_1.expect)(results).toHaveLength(3);
+        results.forEach((result) => {
+            (0, vitest_1.expect)(result).toHaveProperty('name');
+            (0, vitest_1.expect)(result).toHaveProperty('input_schema');
+        });
+    });
+    (0, vitest_1.it)('should adapt multiple tools to Gemini format', () => {
+        const results = (0, index_1.adaptAll)(tools, 'gemini');
+        (0, vitest_1.expect)(results).toHaveLength(3);
+        results.forEach((result) => {
+            (0, vitest_1.expect)(result).toHaveProperty('name');
+            (0, vitest_1.expect)(result).toHaveProperty('parameters');
+        });
+    });
+    (0, vitest_1.it)('should adapt multiple tools to Mistral format', () => {
+        const results = (0, index_1.adaptAll)(tools, 'mistral');
+        (0, vitest_1.expect)(results).toHaveLength(3);
+        results.forEach((result) => {
+            (0, vitest_1.expect)(result).toHaveProperty('type', 'function');
+            (0, vitest_1.expect)(result).toHaveProperty('function');
+        });
+    });
+    (0, vitest_1.it)('should handle empty array', () => {
+        const results = (0, index_1.adaptAll)([], 'openai');
+        (0, vitest_1.expect)(results).toEqual([]);
+    });
+    (0, vitest_1.it)('should throw error for unknown provider', () => {
+        (0, vitest_1.expect)(() => {
+            (0, index_1.adaptAll)(tools, 'invalid');
+        }).toThrow('Unknown provider');
+    });
+});
+(0, vitest_1.describe)('getProviders', () => {
+    (0, vitest_1.it)('should return array of all supported providers', () => {
+        const providers = (0, index_1.getProviders)();
+        (0, vitest_1.expect)(providers).toBeInstanceOf(Array);
+        (0, vitest_1.expect)(providers).toHaveLength(4);
+    });
+    (0, vitest_1.it)('should include all four providers', () => {
+        const providers = (0, index_1.getProviders)();
+        (0, vitest_1.expect)(providers).toContain('openai');
+        (0, vitest_1.expect)(providers).toContain('anthropic');
+        (0, vitest_1.expect)(providers).toContain('gemini');
+        (0, vitest_1.expect)(providers).toContain('mistral');
+    });
+});
+(0, vitest_1.describe)('Cross-provider consistency', () => {
+    const tool = {
+        name: 'test_tool',
+        description: 'A test tool for validation',
+        params: {
+            required_param: {
+                type: 'string',
+                description: 'A required parameter',
+                required: true,
+            },
+            optional_param: {
+                type: 'number',
+                description: 'An optional parameter',
+                default: 42,
+            },
+            enum_param: {
+                type: 'string',
+                enum: ['option1', 'option2', 'option3'],
+            },
+            array_param: {
+                type: 'array',
+                items: { type: 'string' },
+            },
+        },
+    };
+    (0, vitest_1.it)('should preserve tool name across all providers', () => {
+        const openai = (0, index_1.adapt)(tool, 'openai');
+        const anthropic = (0, index_1.adapt)(tool, 'anthropic');
+        const gemini = (0, index_1.adapt)(tool, 'gemini');
+        const mistral = (0, index_1.adapt)(tool, 'mistral');
+        (0, vitest_1.expect)(openai.function.name).toBe('test_tool');
+        (0, vitest_1.expect)(anthropic.name).toBe('test_tool');
+        (0, vitest_1.expect)(gemini.name).toBe('test_tool');
+        (0, vitest_1.expect)(mistral.function.name).toBe('test_tool');
+    });
+    (0, vitest_1.it)('should preserve tool description across all providers', () => {
+        const openai = (0, index_1.adapt)(tool, 'openai');
+        const anthropic = (0, index_1.adapt)(tool, 'anthropic');
+        const gemini = (0, index_1.adapt)(tool, 'gemini');
+        const mistral = (0, index_1.adapt)(tool, 'mistral');
+        (0, vitest_1.expect)(openai.function.description).toBe('A test tool for validation');
+        (0, vitest_1.expect)(anthropic.description).toBe('A test tool for validation');
+        (0, vitest_1.expect)(gemini.description).toBe('A test tool for validation');
+        (0, vitest_1.expect)(mistral.function.description).toBe('A test tool for validation');
+    });
+    (0, vitest_1.it)('should preserve required params across all providers', () => {
+        const openai = (0, index_1.adapt)(tool, 'openai');
+        const anthropic = (0, index_1.adapt)(tool, 'anthropic');
+        const gemini = (0, index_1.adapt)(tool, 'gemini');
+        const mistral = (0, index_1.adapt)(tool, 'mistral');
+        (0, vitest_1.expect)(openai.function.parameters.required).toContain('required_param');
+        (0, vitest_1.expect)(anthropic.input_schema.required).toContain('required_param');
+        (0, vitest_1.expect)(gemini.parameters.required).toContain('required_param');
+        (0, vitest_1.expect)(mistral.function.parameters.required).toContain('required_param');
+    });
+    (0, vitest_1.it)('should preserve enum values across all providers', () => {
+        const openai = (0, index_1.adapt)(tool, 'openai');
+        const anthropic = (0, index_1.adapt)(tool, 'anthropic');
+        const gemini = (0, index_1.adapt)(tool, 'gemini');
+        const mistral = (0, index_1.adapt)(tool, 'mistral');
+        const expectedEnum = ['option1', 'option2', 'option3'];
+        (0, vitest_1.expect)(openai.function.parameters.properties.enum_param.enum).toEqual(expectedEnum);
+        (0, vitest_1.expect)(anthropic.input_schema.properties.enum_param.enum).toEqual(expectedEnum);
+        (0, vitest_1.expect)(gemini.parameters.properties.enum_param.enum).toEqual(expectedEnum);
+        (0, vitest_1.expect)(mistral.function.parameters.properties.enum_param.enum).toEqual(expectedEnum);
+    });
+    (0, vitest_1.it)('should preserve default values across all providers', () => {
+        const openai = (0, index_1.adapt)(tool, 'openai');
+        const anthropic = (0, index_1.adapt)(tool, 'anthropic');
+        const gemini = (0, index_1.adapt)(tool, 'gemini');
+        const mistral = (0, index_1.adapt)(tool, 'mistral');
+        (0, vitest_1.expect)(openai.function.parameters.properties.optional_param.default).toBe(42);
+        (0, vitest_1.expect)(anthropic.input_schema.properties.optional_param.default).toBe(42);
+        (0, vitest_1.expect)(gemini.parameters.properties.optional_param.default).toBe(42);
+        (0, vitest_1.expect)(mistral.function.parameters.properties.optional_param.default).toBe(42);
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Universal AI Tool Schema Adapter - Type Definitions
+ *
+ * This is the Single Source of Truth for the data contract.
+ * All adapters import from here to ensure consistency.
+ */
+/**
+ * Supported parameter types in the universal schema
+ */
+export type ParamType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+/**
+ * Parameter definition in the universal tool schema
+ */
+export interface ToolParam {
+    /** The type of this parameter */
+    type: ParamType;
+    /** Human-readable description of what this parameter does */
+    description?: string;
+    /** Whether this parameter is required (default: false) */
+    required?: boolean;
+    /** Default value for this parameter */
+    default?: unknown;
+    /** Allowed values for this parameter (for enum-like behavior) */
+    enum?: string[];
+    /** For array types, defines the type of array items */
+    items?: {
+        type: ParamType;
+    };
+    /** For object types, defines nested properties */
+    properties?: Record<string, ToolParam>;
+}
+/**
+ * Universal tool definition that can be converted to any provider format
+ *
+ * This is the core data contract. Changes to this interface require
+ * a MAJOR version bump per semantic versioning rules.
+ */
+export interface UniversalTool {
+    /** Function/tool name - must be valid identifier */
+    name: string;
+    /** Human-readable description of what this tool does */
+    description: string;
+    /** Parameter definitions for this tool */
+    params: Record<string, ToolParam>;
+}
+/**
+ * Supported AI provider platforms
+ *
+ * Adding new providers requires:
+ * 1. Adding the provider name to this union type
+ * 2. Creating a new adapter in src/adapters/
+ * 3. Registering the adapter in src/index.ts
+ * 4. Adding test coverage
+ */
+export type Provider = 'openai' | 'anthropic' | 'gemini' | 'mistral';

package/dist/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Universal AI Tool Schema Adapter - Type Definitions
+ *
+ * This is the Single Source of Truth for the data contract.
+ * All adapters import from here to ensure consistency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-tool-adapter",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Universal tool schema adapter for AI providers (OpenAI, Anthropic, Gemini, Mistral)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,8 @@
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "ai",
@@ -27,6 +28,7 @@
   "license": "ISC",
   "type": "commonjs",
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "4.0.17"
   }
 }