@spec2tools/core 0.1.1 → 0.2.0

package/README.md

@@ -64,6 +64,39 @@ const tools = createExecutableTools(toolDefs, baseUrl, authManager);
 const result = await executeToolByName(tools, 'getUser', { id: '123' });
 ```
 
+### AI SDK Tools
+
+```ts
+import { toAISDKTools } from '@spec2tools/core';
+
+// Convert core tools to AI SDK-compatible ToolSet
+const aiTools = toAISDKTools(tools);
+```
+
+### Code Mode
+
+Collapse any AI SDK `ToolSet` into 2 tools (`search` + `execute`). The model discovers endpoints via keyword search and calls them by writing Python code, executed in a sandboxed [Monty](https://github.com/pydantic/monty) interpreter.
+
+```ts
+import { toCodeModeTools } from '@spec2tools/core';
+
+// Convert N tools into 2 code-mode tools
+const codeModeTools = toCodeModeTools(aiTools);
+```
+
+This also works with tools from any MCP server via the AI SDK:
+
+```ts
+import { createMCPClient } from 'ai';
+import { toCodeModeTools } from '@spec2tools/core';
+
+const client = await createMCPClient({
+  transport: { type: 'sse', url: 'http://localhost:3000/sse' },
+});
+
+const tools = toCodeModeTools(await client.tools());
+```
+
 ### Error Classes
 
 ```ts

package/dist/ai-tools.d.ts

@@ -0,0 +1,13 @@
+import { generateText } from 'ai';
+import type { Tool } from './types.js';
+type ToolSet = NonNullable<Parameters<typeof generateText>[0]['tools']>;
+/**
+ * Convert core Tool[] into AI SDK ToolSet.
+ *
+ * Wraps each core tool with the `ai` package's `tool()` helper,
+ * producing a `Record<string, CoreTool>` compatible with `generateText`,
+ * `streamText`, etc.
+ */
+export declare function toAISDKTools(tools: Tool[]): ToolSet;
+export type { ToolSet };
+//# sourceMappingURL=ai-tools.d.ts.map

package/dist/ai-tools.js

@@ -0,0 +1,22 @@
+import { tool } from 'ai';
+/**
+ * Convert core Tool[] into AI SDK ToolSet.
+ *
+ * Wraps each core tool with the `ai` package's `tool()` helper,
+ * producing a `Record<string, CoreTool>` compatible with `generateText`,
+ * `streamText`, etc.
+ */
+export function toAISDKTools(tools) {
+    const aiTools = {};
+    for (const t of tools) {
+        aiTools[t.name] = tool({
+            description: t.description,
+            inputSchema: t.parameters,
+            execute: async (params) => {
+                return t.execute(params);
+            },
+        });
+    }
+    return aiTools;
+}
+//# sourceMappingURL=ai-tools.js.map

package/dist/code-mode.d.ts

@@ -0,0 +1,12 @@
+import { generateText } from 'ai';
+type ToolSet = NonNullable<Parameters<typeof generateText>[0]['tools']>;
+/**
+ * Transform an AI SDK ToolSet into exactly 2 code-mode tools: `search` and `execute`.
+ *
+ * The model discovers endpoints via keyword search and calls them by writing
+ * Python code that is executed in a sandboxed Monty interpreter. This reduces
+ * token consumption by ~99.9% for large APIs (N tools → 2 tools).
+ */
+export declare function toCodeModeTools(tools: ToolSet): ToolSet;
+export {};
+//# sourceMappingURL=code-mode.d.ts.map

package/dist/code-mode.js

@@ -0,0 +1,233 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { Monty, MontySnapshot, MontyRuntimeError, MontySyntaxError, MontyTypingError, } from '@pydantic/monty';
+/**
+ * Convert a tool name into a valid Python identifier.
+ * Replaces hyphens, dots, spaces, etc. with underscores and
+ * prefixes with `_` if the name starts with a digit.
+ */
+function toPythonName(name) {
+    let py = name.replace(/[^a-zA-Z0-9_]/g, '_');
+    if (/^[0-9]/.test(py))
+        py = `_${py}`;
+    return py || '_unnamed';
+}
+function jsonSchemaTypeToPython(schema) {
+    if (!schema)
+        return 'any';
+    const type = schema.type;
+    if (type === 'string')
+        return 'str';
+    if (type === 'integer')
+        return 'int';
+    if (type === 'number')
+        return 'float';
+    if (type === 'boolean')
+        return 'bool';
+    if (type === 'array')
+        return 'list';
+    if (type === 'object')
+        return 'dict';
+    if (schema.enum)
+        return 'str';
+    return 'any';
+}
+function buildIndex(tools) {
+    const index = [];
+    for (const [name, t] of Object.entries(tools)) {
+        const pyName = toPythonName(name);
+        const description = 'description' in t ? (t.description || '') : '';
+        const params = [];
+        try {
+            // AI SDK tool() stores the schema as inputSchema (raw Zod)
+            // but other wrappers may use parameters
+            const schema = ('inputSchema' in t ? t.inputSchema : null) ??
+                ('parameters' in t ? t.parameters : null);
+            if (schema && typeof schema === 'object') {
+                const schemaObj = schema;
+                let jsonSchema = null;
+                // AI SDK Schema wrapper — has a jsonSchema property
+                if ('jsonSchema' in schemaObj && schemaObj.jsonSchema) {
+                    jsonSchema = schemaObj.jsonSchema;
+                }
+                // Raw Zod schema — has _def property
+                else if ('_def' in schemaObj) {
+                    jsonSchema = zodToJsonSchema(schema, {
+                        target: 'jsonSchema7',
+                    });
+                }
+                if (jsonSchema) {
+                    const properties = jsonSchema.properties || {};
+                    const required = new Set(jsonSchema.required || []);
+                    for (const [pName, pSchema] of Object.entries(properties)) {
+                        params.push({
+                            name: pName,
+                            type: jsonSchemaTypeToPython(pSchema),
+                            required: required.has(pName),
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Cannot introspect schema; proceed with empty params
+        }
+        const paramStrs = params.map((p) => {
+            if (p.required)
+                return `${p.name}: ${p.type}`;
+            return `${p.name}: ${p.type} = None`;
+        });
+        const signature = `${pyName}(${paramStrs.join(', ')})`;
+        const exampleParams = params
+            .filter((p) => p.required)
+            .slice(0, 2)
+            .map((p) => {
+            if (p.type === 'str')
+                return `${p.name}="..."`;
+            if (p.type === 'int' || p.type === 'float')
+                return `${p.name}=1`;
+            if (p.type === 'bool')
+                return `${p.name}=True`;
+            return `${p.name}=...`;
+        });
+        const example = `${pyName}(${exampleParams.join(', ')})`;
+        index.push({
+            originalName: name,
+            pyName,
+            description,
+            signature,
+            example,
+            searchText: `${name} ${pyName} ${description}`.toLowerCase(),
+        });
+    }
+    return index;
+}
+/**
+ * Recursively convert Monty's Map objects (Python dicts) to plain JS objects
+ * so they JSON.stringify correctly.
+ */
+function montyToJson(value) {
+    if (value instanceof Map) {
+        const obj = {};
+        for (const [k, v] of value) {
+            obj[String(k)] = montyToJson(v);
+        }
+        return obj;
+    }
+    if (Array.isArray(value)) {
+        return value.map(montyToJson);
+    }
+    return value;
+}
+/**
+ * Transform an AI SDK ToolSet into exactly 2 code-mode tools: `search` and `execute`.
+ *
+ * The model discovers endpoints via keyword search and calls them by writing
+ * Python code that is executed in a sandboxed Monty interpreter. This reduces
+ * token consumption by ~99.9% for large APIs (N tools → 2 tools).
+ */
+export function toCodeModeTools(tools) {
+    const index = buildIndex(tools);
+    // Build a mapping from Python-safe names to original tool names
+    const pyToOriginal = new Map();
+    for (const entry of index) {
+        pyToOriginal.set(entry.pyName, entry.originalName);
+    }
+    const pythonNames = [...pyToOriginal.keys()];
+    const searchTool = tool({
+        description: 'Search for available API endpoints by keyword. Returns matching ' +
+            'function signatures with parameter types and usage examples. ' +
+            'Use this to discover what functions are available before writing code.',
+        inputSchema: z.object({
+            query: z
+                .string()
+                .describe('Keywords to search for in endpoint names and descriptions'),
+        }),
+        execute: async ({ query }) => {
+            const keywords = query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter(Boolean);
+            const matches = index.filter((entry) => keywords.some((kw) => entry.searchText.includes(kw)));
+            if (matches.length === 0) {
+                return `No endpoints found matching "${query}". Try different keywords.`;
+            }
+            return matches
+                .map((m) => `${m.signature}\n  ${m.description}\n  Example: ${m.example}`)
+                .join('\n\n');
+        },
+    });
+    const executeTool = tool({
+        description: 'Execute Python code that calls API endpoints. Functions discovered ' +
+            'via search are available to call directly. Always use keyword arguments.\n' +
+            'Example:\n' +
+            '  users = listUsers(limit=10)\n' +
+            '  user = getUser(id="123")\n' +
+            '  users',
+        inputSchema: z.object({
+            code: z
+                .string()
+                .describe('Python code to execute. Use keyword arguments when calling API functions.'),
+        }),
+        execute: async ({ code }) => {
+            try {
+                const m = new Monty(code, { externalFunctions: pythonNames });
+                let progress = m.start({
+                    limits: { maxDurationSecs: 30 },
+                });
+                while (progress instanceof MontySnapshot) {
+                    const snapshot = progress;
+                    const originalName = pyToOriginal.get(snapshot.functionName);
+                    const toolEntry = originalName ? tools[originalName] : undefined;
+                    if (!toolEntry ||
+                        !('execute' in toolEntry) ||
+                        !toolEntry.execute) {
+                        // Should not happen since all tool names are registered,
+                        // but handle gracefully
+                        progress = snapshot.resume({
+                            exception: {
+                                type: 'ValueError',
+                                message: `Unknown function: ${snapshot.functionName}`,
+                            },
+                        });
+                        continue;
+                    }
+                    const params = {
+                        ...snapshot.kwargs,
+                    };
+                    try {
+                        const result = await toolEntry.execute(params, {});
+                        progress = snapshot.resume({ returnValue: result });
+                    }
+                    catch (error) {
+                        progress = snapshot.resume({
+                            exception: {
+                                type: 'RuntimeError',
+                                message: error instanceof Error ? error.message : String(error),
+                            },
+                        });
+                    }
+                }
+                return montyToJson(progress.output);
+            }
+            catch (error) {
+                if (error instanceof MontySyntaxError) {
+                    return `Syntax Error: ${error.message}`;
+                }
+                if (error instanceof MontyRuntimeError) {
+                    return `Runtime Error: ${error.message}\n${error.traceback()}`;
+                }
+                if (error instanceof MontyTypingError) {
+                    return `Type Error: ${error.displayDiagnostics()}`;
+                }
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+    return {
+        search: searchTool,
+        execute: executeTool,
+    };
+}
+//# sourceMappingURL=code-mode.js.map

package/dist/index.d.ts

@@ -3,4 +3,7 @@ export type { HttpMethod, Tool, AuthType, AuthConfig, Session, OpenAPISpec, Path
 export { loadOpenAPISpec, extractBaseUrl, extractAuthConfig, extractOperationAuthConfig, parseOperations, formatToolSchema, formatToolSignature, } from './openapi-parser.js';
 export { AuthManager } from './auth-manager.js';
 export { createExecutableTools, executeToolByName } from './tool-executor.js';
+export { toAISDKTools } from './ai-tools.js';
+export type { ToolSet } from './ai-tools.js';
+export { toCodeModeTools } from './code-mode.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -6,4 +6,8 @@ export { loadOpenAPISpec, extractBaseUrl, extractAuthConfig, extractOperationAut
 export { AuthManager } from './auth-manager.js';
 // Tool Executor
 export { createExecutableTools, executeToolByName } from './tool-executor.js';
+// AI SDK Tools
+export { toAISDKTools } from './ai-tools.js';
+// Code Mode
+export { toCodeModeTools } from './code-mode.js';
 //# sourceMappingURL=index.js.map

package/dist/openapi-parser.js

@@ -109,10 +109,39 @@ function parseSecurityScheme(scheme, scopes) {
     }
     return { type: 'none' };
 }
+/**
+ * Resolve a $ref to its actual schema object
+ */
+function resolveRef(ref, spec, visited = new Set()) {
+    // Detect circular references
+    if (visited.has(ref)) {
+        throw new UnsupportedSchemaError(ref, 'Circular $ref detected');
+    }
+    visited.add(ref);
+    // Only support #/components/schemas/ references
+    if (!ref.startsWith('#/components/schemas/')) {
+        throw new UnsupportedSchemaError(ref, 'Only #/components/schemas/ $refs are supported');
+    }
+    const schemaName = ref.replace('#/components/schemas/', '');
+    const schema = spec.components?.schemas?.[schemaName];
+    if (!schema) {
+        throw new UnsupportedSchemaError(ref, `Schema "${schemaName}" not found in components`);
+    }
+    // If the resolved schema has a $ref, resolve it recursively
+    if (schema.$ref) {
+        return resolveRef(schema.$ref, spec, visited);
+    }
+    return schema;
+}
 /**
  * Convert an OpenAPI schema to a Zod schema
  */
-function schemaToZod(schema, path, depth = 0) {
+function schemaToZod(schema, path, spec, depth = 0, visited = new Set()) {
+    // Resolve $ref if present
+    if (schema.$ref) {
+        const resolvedSchema = resolveRef(schema.$ref, spec, new Set(visited));
+        return schemaToZod(resolvedSchema, path, spec, depth, visited);
+    }
     // Check for unsupported features
     if (schema.anyOf) {
         throw new UnsupportedSchemaError(path, 'anyOf is not supported');
@@ -123,9 +152,6 @@ function schemaToZod(schema, path, depth = 0) {
     if (schema.allOf) {
         throw new UnsupportedSchemaError(path, 'allOf is not supported');
     }
-    if (schema.$ref) {
-        throw new UnsupportedSchemaError(path, '$ref is not supported');
-    }
     // Handle array types
     if (schema.type === 'array') {
         if (!schema.items) {
@@ -134,7 +160,7 @@ function schemaToZod(schema, path, depth = 0) {
         if (schema.items.type === 'object') {
             throw new UnsupportedSchemaError(path, 'Arrays of objects are not supported');
         }
-        const itemSchema = schemaToZod(schema.items, `${path}.items`, depth);
+        const itemSchema = schemaToZod(schema.items, `${path}.items`, spec, depth, visited);
         let arraySchema = z.array(itemSchema);
         if (schema.description) {
             arraySchema = arraySchema.describe(schema.description);
@@ -150,7 +176,7 @@ function schemaToZod(schema, path, depth = 0) {
         const required = schema.required || [];
         const shape = {};
         for (const [propName, propSchema] of Object.entries(properties)) {
-            let zodProp = schemaToZod(propSchema, `${path}.${propName}`, depth + 1);
+            let zodProp = schemaToZod(propSchema, `${path}.${propName}`, spec, depth + 1, visited);
             if (!required.includes(propName)) {
                 zodProp = zodProp.optional();
             }
@@ -197,15 +223,17 @@ function schemaToZod(schema, path, depth = 0) {
 /**
  * Build parameters schema from path and query parameters
  */
-function buildParametersSchema(parameters, operationId) {
+function buildParametersSchema(parameters, operationId, spec) {
     const shape = {};
+    const pathParams = new Set();
+    const queryParams = new Set();
     for (const param of parameters) {
         if (param.in !== 'path' && param.in !== 'query') {
             continue; // Skip header and cookie parameters
         }
         let paramSchema;
         if (param.schema) {
-            paramSchema = schemaToZod(param.schema, `${operationId}.parameters.${param.name}`, 0);
+            paramSchema = schemaToZod(param.schema, `${operationId}.parameters.${param.name}`, spec, 0);
         }
         else {
             paramSchema = z.string();
@@ -217,45 +245,58 @@ function buildParametersSchema(parameters, operationId) {
             paramSchema = paramSchema.optional();
         }
         shape[param.name] = paramSchema;
+        // Track which set this parameter belongs to
+        if (param.in === 'path') {
+            pathParams.add(param.name);
+        }
+        else if (param.in === 'query') {
+            queryParams.add(param.name);
+        }
     }
-    return shape;
+    return { shape, pathParams, queryParams };
 }
 /**
  * Build request body schema
  */
-function buildRequestBodySchema(operation, operationId) {
+function buildRequestBodySchema(operation, operationId, spec) {
+    const shape = {};
+    const bodyParams = new Set();
     if (!operation.requestBody?.content) {
-        return {};
+        return { shape, bodyParams };
     }
     const jsonContent = operation.requestBody.content['application/json'];
     if (!jsonContent?.schema) {
-        return {};
+        return { shape, bodyParams };
     }
     const schema = jsonContent.schema;
     // Check for file uploads
     if (schema.type === 'string' && schema.format === 'binary') {
         throw new UnsupportedSchemaError(`${operationId}.requestBody`, 'File uploads are not supported');
     }
+    // Resolve $ref if present
+    let resolvedSchema = schema;
+    if (schema.$ref) {
+        resolvedSchema = resolveRef(schema.$ref, spec);
+    }
     // For object schemas, flatten properties into the parameter shape
-    if (schema.type === 'object' || schema.properties) {
-        const properties = schema.properties || {};
-        const required = schema.required || [];
-        const shape = {};
+    if (resolvedSchema.type === 'object' || resolvedSchema.properties) {
+        const properties = resolvedSchema.properties || {};
+        const required = resolvedSchema.required || [];
         for (const [propName, propSchema] of Object.entries(properties)) {
             // Check for file upload in properties
             if (propSchema.type === 'string' &&
                 propSchema.format === 'binary') {
                 throw new UnsupportedSchemaError(`${operationId}.requestBody.${propName}`, 'File uploads are not supported');
             }
-            let zodProp = schemaToZod(propSchema, `${operationId}.requestBody.${propName}`, 1);
+            let zodProp = schemaToZod(propSchema, `${operationId}.requestBody.${propName}`, spec, 1);
             if (!required.includes(propName)) {
                 zodProp = zodProp.optional();
             }
             shape[propName] = zodProp;
+            bodyParams.add(propName); // Track that this is a body parameter
         }
-        return shape;
     }
-    return {};
+    return { shape, bodyParams };
 }
 /**
  * Generate tool name from operation
@@ -292,9 +333,9 @@ export function parseOperations(spec) {
                 ...(operation.parameters || []),
             ];
             // Build combined schema from parameters and request body
-            const parameterShape = buildParametersSchema(allParameters, operationId);
-            const bodyShape = buildRequestBodySchema(operation, operationId);
-            const combinedShape = { ...parameterShape, ...bodyShape };
+            const parametersResult = buildParametersSchema(allParameters, operationId, spec);
+            const bodyResult = buildRequestBodySchema(operation, operationId, spec);
+            const combinedShape = { ...parametersResult.shape, ...bodyResult.shape };
             const parameters = z.object(combinedShape);
             // Extract operation-specific auth config
             const authConfig = extractOperationAuthConfig(spec, operation);
@@ -305,6 +346,11 @@ export function parseOperations(spec) {
                 httpMethod: method,
                 path,
                 authConfig,
+                parameterMetadata: {
+                    pathParams: parametersResult.pathParams,
+                    queryParams: parametersResult.queryParams,
+                    bodyParams: bodyResult.bodyParams,
+                },
             });
         }
     }

package/dist/tool-executor.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Tool, HttpMethod, AuthConfig } from './types.js';
+import { Tool, HttpMethod, AuthConfig, ParameterMetadata } from './types.js';
 import { AuthManager } from './auth-manager.js';
 interface ToolDefinition {
     name: string;
@@ -8,6 +8,7 @@ interface ToolDefinition {
     httpMethod: HttpMethod;
     path: string;
     authConfig?: AuthConfig;
+    parameterMetadata?: ParameterMetadata;
 }
 /**
  * Create executable tools from tool definitions

package/dist/tool-executor.js

@@ -19,8 +19,8 @@ function createExecutor(tool, baseUrl, authManager) {
             const validatedParams = tool.parameters.parse(params);
             // Build URL with path parameters replaced
             let url = buildUrl(baseUrl, tool.path, validatedParams);
-            // Separate path, query, and body parameters
-            const { queryParams, bodyParams } = separateParams(validatedParams, tool.path);
+            // Separate path, query, and body parameters using metadata
+            const { queryParams, bodyParams } = separateParams(validatedParams, tool.parameterMetadata);
             // Add query parameters
             const urlObj = new URL(url);
             for (const [key, value] of Object.entries(queryParams)) {
@@ -122,39 +122,55 @@ function buildUrl(baseUrl, path, params) {
     return `${baseUrl}${finalPath}`;
 }
 /**
- * Separate parameters into path, query, and body params
+ * Separate parameters into path, query, and body params using metadata
  */
-function separateParams(params, path) {
+function separateParams(params, metadata) {
     const pathParams = {};
     const queryParams = {};
     const bodyParams = {};
-    // Extract path parameter names
-    const pathParamNames = new Set();
-    const pathParamRegex = /\{(\w+)\}/g;
-    let match;
-    while ((match = pathParamRegex.exec(path)) !== null) {
-        pathParamNames.add(match[1]);
-    }
-    for (const [key, value] of Object.entries(params)) {
-        if (pathParamNames.has(key)) {
-            pathParams[key] = value;
-        }
-        else if (isPrimitive(value)) {
-            // Primitive values go to query params
-            queryParams[key] = value;
+    // If we have metadata, use it to categorize parameters
+    if (metadata) {
+        for (const [key, value] of Object.entries(params)) {
+            if (metadata.pathParams.has(key)) {
+                pathParams[key] = value;
+            }
+            else if (metadata.queryParams.has(key)) {
+                queryParams[key] = value;
+            }
+            else if (metadata.bodyParams.has(key)) {
+                bodyParams[key] = value;
+            }
+            else {
+                // Fallback: if not in metadata, treat as body param
+                bodyParams[key] = value;
+            }
         }
-        else {
-            // Complex values go to body
-            bodyParams[key] = value;
+    }
+    else {
+        // Fallback to old behavior if no metadata (shouldn't happen with new parser)
+        // This keeps backward compatibility
+        const pathParamNames = extractPathParamNames(params);
+        for (const [key, value] of Object.entries(params)) {
+            if (pathParamNames.has(key)) {
+                pathParams[key] = value;
+            }
+            else if (isPrimitive(value)) {
+                queryParams[key] = value;
+            }
+            else {
+                bodyParams[key] = value;
+            }
         }
     }
-    // For simplicity, if there are non-path primitive params,
-    // we need to determine if they're query or body based on HTTP method
-    // Since we don't have that info here, we'll treat all non-path primitives
-    // as potential query params for GET/DELETE, and body params for POST/PUT/PATCH
-    // This is handled by the executor which knows the method
     return { pathParams, queryParams, bodyParams };
 }
+/**
+ * Extract path parameter names from params (fallback)
+ */
+function extractPathParamNames(params) {
+    // This is a fallback - in practice, metadata should always be provided
+    return new Set();
+}
 /**
  * Check if value is a primitive type
  */

package/dist/types.d.ts

@@ -1,5 +1,13 @@
 import { z } from 'zod';
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface ParameterMetadata {
+    /** Parameters that come from path (e.g., {id} in /users/{id}) */
+    pathParams: Set<string>;
+    /** Parameters that come from query string */
+    queryParams: Set<string>;
+    /** Parameters that come from request body */
+    bodyParams: Set<string>;
+}
 export interface Tool {
     name: string;
     description: string;
@@ -8,6 +16,7 @@ export interface Tool {
     httpMethod: HttpMethod;
     path: string;
     authConfig?: AuthConfig;
+    parameterMetadata?: ParameterMetadata;
 }
 export type AuthType = 'oauth2' | 'apiKey' | 'bearer' | 'basic' | 'none';
 export interface AuthConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spec2tools/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Core utilities for OpenAPI parsing and authentication",
   "type": "module",
   "main": "dist/index.js",
@@ -28,6 +28,8 @@
     "directory": "packages/core"
   },
   "dependencies": {
+    "@pydantic/monty": "^0.0.7",
+    "ai": "^6.0.68",
     "express": "^5.0.0",
     "open": "^10.1.0",
     "yaml": "^2.5.0",
@@ -37,7 +39,8 @@
   "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/node": "^22.0.0",
-    "typescript": "^5.6.0"
+    "typescript": "^5.6.0",
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -45,6 +48,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }