@happyvertical/smrt-core 0.30.0

package/dist/tools/tool-executor.js

@@ -0,0 +1,142 @@
+import { createLogger } from "@happyvertical/logger";
+import { ValidationError, RuntimeError } from "../errors.js";
+const logger = createLogger({ level: "info" });
+function validateToolCall(methodName, args, allowedMethods) {
+  if (!allowedMethods.includes(methodName)) {
+    throw ValidationError.invalidValue(
+      "methodName",
+      methodName,
+      `Method must be one of: ${allowedMethods.join(", ")}`
+    );
+  }
+  if (typeof args !== "object" || args === null) {
+    throw ValidationError.invalidValue(
+      "arguments",
+      args,
+      "Arguments must be a valid object"
+    );
+  }
+}
+async function executeToolCall(instance, toolCall, allowedMethods, signalBus) {
+  const startTime = Date.now();
+  const methodName = toolCall.function.name;
+  const executionId = signalBus?.generateExecutionId() ?? toolCall.id;
+  let args;
+  try {
+    try {
+      args = JSON.parse(toolCall.function.arguments);
+    } catch (_parseError) {
+      throw ValidationError.invalidValue(
+        "arguments",
+        toolCall.function.arguments,
+        "Arguments must be valid JSON"
+      );
+    }
+    if (!args) {
+      throw ValidationError.invalidValue(
+        "arguments",
+        toolCall.function.arguments,
+        "Arguments must be a valid object"
+      );
+    }
+    validateToolCall(methodName, args, allowedMethods);
+    if (typeof instance[methodName] !== "function") {
+      throw RuntimeError.operationFailed(
+        `Method '${methodName}' not found on object`
+      );
+    }
+    if (signalBus) {
+      const startSignal = {
+        id: executionId,
+        objectId: instance.id ?? "unknown",
+        className: instance.constructor?.name ?? "Unknown",
+        method: methodName,
+        type: "start",
+        args: [args],
+        // Wrap in array for consistency
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await signalBus.emit(startSignal);
+    }
+    const result = await instance[methodName](args);
+    if (signalBus) {
+      const endSignal = {
+        id: executionId,
+        objectId: instance.id ?? "unknown",
+        className: instance.constructor?.name ?? "Unknown",
+        method: methodName,
+        type: "end",
+        args: [args],
+        result,
+        duration: Date.now() - startTime,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await signalBus.emit(endSignal);
+    }
+    return {
+      id: toolCall.id,
+      methodName,
+      arguments: args,
+      result,
+      success: true,
+      duration: Date.now() - startTime
+    };
+  } catch (error) {
+    if (signalBus) {
+      const errorSignal = {
+        id: executionId,
+        objectId: instance.id ?? "unknown",
+        className: instance.constructor?.name ?? "Unknown",
+        method: methodName,
+        type: "error",
+        // Preserve actual args if parsed, otherwise include raw arguments for debugging
+        args: [
+          typeof args !== "undefined" ? args : toolCall.function.arguments
+        ],
+        error: error instanceof Error ? error : new Error(String(error)),
+        duration: Date.now() - startTime,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await signalBus.emit(errorSignal);
+    }
+    return {
+      id: toolCall.id,
+      methodName,
+      arguments: {},
+      result: null,
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      duration: Date.now() - startTime
+    };
+  }
+}
+async function executeToolCalls(instance, toolCalls, allowedMethods, signalBus) {
+  const results = [];
+  for (const toolCall of toolCalls) {
+    const result = await executeToolCall(
+      instance,
+      toolCall,
+      allowedMethods,
+      signalBus
+    );
+    results.push(result);
+    if (!result.success) {
+      logger.warn(`Tool call failed for ${result.methodName}: ${result.error}`);
+    }
+  }
+  return results;
+}
+function formatToolResults(results) {
+  return results.map((result) => ({
+    role: "tool",
+    tool_call_id: result.id,
+    content: result.success ? JSON.stringify(result.result) : `Error: ${result.error}`
+  }));
+}
+export {
+  executeToolCall,
+  executeToolCalls,
+  formatToolResults,
+  validateToolCall
+};
+//# sourceMappingURL=tool-executor.js.map

package/dist/tools/tool-executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-executor.js","sources":["../../src/tools/tool-executor.ts"],"sourcesContent":["/**\n * Tool Call Execution for AI Function Calling\n *\n * This module handles runtime execution of AI tool calls on SMRT object instances.\n */\n\nimport { createLogger } from '@happyvertical/logger';\nimport type { Signal } from '@happyvertical/smrt-types';\nimport { RuntimeError, ValidationError } from '../errors.js';\nimport type { SignalBus } from '../signals/bus.js';\n\nconst logger = createLogger({ level: 'info' });\n\n/**\n * Tool call structure from AI response\n */\nexport interface ToolCall {\n  /**\n   * Unique identifier for this tool call\n   */\n  id: string;\n\n  /**\n   * Type of tool (always 'function' for now)\n   */\n  type: 'function';\n\n  /**\n   * Function details\n   */\n  function: {\n    /**\n     * Name of the method to call\n     */\n    name: string;\n\n    /**\n     * JSON string of arguments to pass to the method\n     */\n    arguments: string;\n  };\n}\n\n/**\n * Result of executing a tool call\n */\nexport interface ToolCallResult {\n  /**\n   * Tool call ID for correlation\n   */\n  id: string;\n\n  /**\n   * Method name that was called\n   */\n  methodName: string;\n\n  /**\n   * Parsed arguments that were used\n   */\n  arguments: Record<string, any>;\n\n  /**\n   * Result returned from the method\n   */\n  result: any;\n\n  /**\n   * Whether the call succeeded\n   */\n  success: boolean;\n\n  /**\n   * Error message if call failed\n   */\n  error?: string;\n\n  /**\n   * Execution time in milliseconds\n   */\n  duration?: number;\n}\n\n/**\n * Validates tool call arguments against method parameters\n *\n * @param methodName - Name of the method being called\n * @param args - Parsed arguments from tool call\n * @param allowedMethods - List of methods AI is allowed to call\n * @throws ValidationError if method not allowed or arguments invalid\n */\nexport function validateToolCall(\n  methodName: string,\n  args: Record<string, any>,\n  allowedMethods: string[],\n): void {\n  // Check if method is allowed\n  if (!allowedMethods.includes(methodName)) {\n    throw ValidationError.invalidValue(\n      'methodName',\n      methodName,\n      `Method must be one of: ${allowedMethods.join(', ')}`,\n    );\n  }\n\n  // Basic argument validation (could be enhanced)\n  if (typeof args !== 'object' || args === null) {\n    throw ValidationError.invalidValue(\n      'arguments',\n      args,\n      'Arguments must be a valid object',\n    );\n  }\n}\n\n/**\n * Executes a tool call on an object instance\n *\n * @param instance - Object instance to call method on\n * @param toolCall - Tool call from AI\n * @param allowedMethods - List of methods AI is allowed to call\n * @param signalBus - Optional signal bus for emitting execution events\n * @returns Result of the tool call execution\n */\nexport async function executeToolCall(\n  instance: any,\n  toolCall: ToolCall,\n  allowedMethods: string[],\n  signalBus?: SignalBus,\n): Promise<ToolCallResult> {\n  const startTime = Date.now();\n  const methodName = toolCall.function.name;\n  const executionId = signalBus?.generateExecutionId() ?? toolCall.id;\n\n  // Declare args outside try blocks so it's accessible in catch block\n  let args: Record<string, any> | undefined;\n\n  try {\n    // Parse arguments\n    try {\n      args = JSON.parse(toolCall.function.arguments);\n    } catch (_parseError) {\n      throw ValidationError.invalidValue(\n        'arguments',\n        toolCall.function.arguments,\n        'Arguments must be valid JSON',\n      );\n    }\n\n    // Type guard - args is always defined after successful parsing\n    if (!args) {\n      throw ValidationError.invalidValue(\n        'arguments',\n        toolCall.function.arguments,\n        'Arguments must be a valid object',\n      );\n    }\n\n    // Validate tool call\n    validateToolCall(methodName, args, allowedMethods);\n\n    // Check method exists\n    if (typeof instance[methodName] !== 'function') {\n      throw RuntimeError.operationFailed(\n        `Method '${methodName}' not found on object`,\n      );\n    }\n\n    // Emit start signal\n    if (signalBus) {\n      const startSignal: Signal = {\n        id: executionId,\n        objectId: instance.id ?? 'unknown',\n        className: instance.constructor?.name ?? 'Unknown',\n        method: methodName,\n        type: 'start',\n        args: [args], // Wrap in array for consistency\n        timestamp: new Date(),\n      };\n      await signalBus.emit(startSignal);\n    }\n\n    // Execute method\n    const result = await instance[methodName](args);\n\n    // Emit end signal\n    if (signalBus) {\n      const endSignal: Signal = {\n        id: executionId,\n        objectId: instance.id ?? 'unknown',\n        className: instance.constructor?.name ?? 'Unknown',\n        method: methodName,\n        type: 'end',\n        args: [args],\n        result,\n        duration: Date.now() - startTime,\n        timestamp: new Date(),\n      };\n      await signalBus.emit(endSignal);\n    }\n\n    return {\n      id: toolCall.id,\n      methodName,\n      arguments: args,\n      result,\n      success: true,\n      duration: Date.now() - startTime,\n    };\n  } catch (error) {\n    // Emit error signal\n    if (signalBus) {\n      const errorSignal: Signal = {\n        id: executionId,\n        objectId: instance.id ?? 'unknown',\n        className: instance.constructor?.name ?? 'Unknown',\n        method: methodName,\n        type: 'error',\n        // Preserve actual args if parsed, otherwise include raw arguments for debugging\n        args: [\n          typeof args !== 'undefined' ? args : toolCall.function.arguments,\n        ],\n        error: error instanceof Error ? error : new Error(String(error)),\n        duration: Date.now() - startTime,\n        timestamp: new Date(),\n      };\n      await signalBus.emit(errorSignal);\n    }\n\n    return {\n      id: toolCall.id,\n      methodName,\n      arguments: {},\n      result: null,\n      success: false,\n      error: error instanceof Error ? error.message : String(error),\n      duration: Date.now() - startTime,\n    };\n  }\n}\n\n/**\n * Executes multiple tool calls in sequence\n *\n * @param instance - Object instance to call methods on\n * @param toolCalls - Array of tool calls from AI\n * @param allowedMethods - List of methods AI is allowed to call\n * @param signalBus - Optional signal bus for emitting execution events\n * @returns Array of tool call results\n */\nexport async function executeToolCalls(\n  instance: any,\n  toolCalls: ToolCall[],\n  allowedMethods: string[],\n  signalBus?: SignalBus,\n): Promise<ToolCallResult[]> {\n  const results: ToolCallResult[] = [];\n\n  for (const toolCall of toolCalls) {\n    const result = await executeToolCall(\n      instance,\n      toolCall,\n      allowedMethods,\n      signalBus,\n    );\n    results.push(result);\n\n    // Stop on first error if needed\n    if (!result.success) {\n      logger.warn(`Tool call failed for ${result.methodName}: ${result.error}`);\n      // Continue executing other tools (don't break)\n    }\n  }\n\n  return results;\n}\n\n/**\n * Formats tool call results into messages for AI\n *\n * @param results - Tool call execution results\n * @returns Array of tool response messages\n */\nexport function formatToolResults(\n  results: ToolCallResult[],\n): Array<{ role: 'tool'; tool_call_id: string; content: string }> {\n  return results.map((result) => ({\n    role: 'tool' as const,\n    tool_call_id: result.id,\n    content: result.success\n      ? JSON.stringify(result.result)\n      : `Error: ${result.error}`,\n  }));\n}\n"],"names":[],"mappings":"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"}

package/dist/tools/tool-generator.d.ts

@@ -0,0 +1,54 @@
+import { AITool } from '@happyvertical/ai';
+import { MethodDefinition } from '../scanner/types.js';
+/**
+ * Configuration for AI-callable methods
+ */
+export interface AiConfig {
+    /**
+     * Methods that AI can call
+     * - Array of method names, e.g., ['analyze', 'validate']
+     * - 'public-async' to auto-include all public async methods
+     * - 'all' to include all methods (not recommended)
+     */
+    callable?: string[] | 'public-async' | 'all';
+    /**
+     * Methods to exclude from AI calling (higher priority than callable)
+     */
+    exclude?: string[];
+    /**
+     * Additional tool descriptions to override method JSDoc
+     */
+    descriptions?: Record<string, string>;
+}
+/**
+ * Converts a TypeScript type string to JSON Schema format
+ *
+ * @param tsType - TypeScript type string (e.g., 'string', 'number', '{ foo: string }')
+ * @returns JSON Schema representation
+ */
+export declare function convertTypeToJsonSchema(tsType: string): Record<string, any>;
+/**
+ * Determines if a method should be included as an AI-callable tool
+ *
+ * @param method - Method definition from AST scanner
+ * @param config - AI configuration from @smrt decorator
+ * @returns True if method should be callable by AI
+ */
+export declare function shouldIncludeMethod(method: MethodDefinition, config?: AiConfig): boolean;
+/**
+ * Generates an AITool definition from a method definition
+ *
+ * @param method - Method definition from AST scanner
+ * @param config - AI configuration for custom descriptions
+ * @returns AITool definition for LLM function calling
+ */
+export declare function generateToolFromMethod(method: MethodDefinition, config?: AiConfig): AITool;
+/**
+ * Generates tool manifest from method definitions
+ *
+ * @param methods - Array of method definitions from AST scanner
+ * @param config - AI configuration from @smrt decorator
+ * @returns Array of AITool definitions for LLM function calling
+ */
+export declare function generateToolManifest(methods: MethodDefinition[], config?: AiConfig): AITool[];
+//# sourceMappingURL=tool-generator.d.ts.map

package/dist/tools/tool-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-generator.d.ts","sourceRoot":"","sources":["../../src/tools/tool-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,cAAc,GAAG,KAAK,CAAC;IAE7C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAqE3E;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,gBAAgB,EACxB,MAAM,CAAC,EAAE,QAAQ,GAChB,OAAO,CAqCT;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,gBAAgB,EACxB,MAAM,CAAC,EAAE,QAAQ,GAChB,MAAM,CA0CR;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,MAAM,CAAC,EAAE,QAAQ,GAChB,MAAM,EAAE,CAWV"}

package/dist/tools/tool-generator.js

@@ -0,0 +1,121 @@
+function convertTypeToJsonSchema(tsType) {
+  const cleanType = tsType.trim();
+  if (cleanType === "string") {
+    return { type: "string" };
+  }
+  if (cleanType === "number") {
+    return { type: "number" };
+  }
+  if (cleanType === "boolean") {
+    return { type: "boolean" };
+  }
+  if (cleanType === "null") {
+    return { type: "null" };
+  }
+  if (cleanType === "any" || cleanType === "unknown") {
+    return {};
+  }
+  if (cleanType.endsWith("[]")) {
+    const itemType = cleanType.slice(0, -2);
+    return {
+      type: "array",
+      items: convertTypeToJsonSchema(itemType)
+    };
+  }
+  const arrayMatch = cleanType.match(/^Array<(.+)>$/);
+  if (arrayMatch) {
+    return {
+      type: "array",
+      items: convertTypeToJsonSchema(arrayMatch[1])
+    };
+  }
+  if (cleanType.includes("|")) {
+    const options = cleanType.split("|").map((s) => s.trim());
+    if (options.every((opt) => opt.startsWith("'") && opt.endsWith("'"))) {
+      return {
+        type: "string",
+        enum: options.map((opt) => opt.slice(1, -1))
+        // Remove quotes
+      };
+    }
+    return {
+      oneOf: options.map(convertTypeToJsonSchema)
+    };
+  }
+  if (cleanType.startsWith("{") && cleanType.endsWith("}")) {
+    return { type: "object" };
+  }
+  if (cleanType.startsWith("Record<")) {
+    return { type: "object" };
+  }
+  return { type: "string", description: `TypeScript type: ${cleanType}` };
+}
+function shouldIncludeMethod(method, config) {
+  if (!config || !config.callable) {
+    return false;
+  }
+  if (config.exclude?.includes(method.name)) {
+    return false;
+  }
+  if (!method.isPublic) {
+    return false;
+  }
+  if (method.isStatic) {
+    return false;
+  }
+  if (config.callable === "all") {
+    return true;
+  }
+  if (config.callable === "public-async") {
+    return method.async;
+  }
+  if (Array.isArray(config.callable)) {
+    return config.callable.includes(method.name);
+  }
+  return false;
+}
+function generateToolFromMethod(method, config) {
+  const parameters = {
+    type: "object",
+    properties: {},
+    required: []
+  };
+  for (const param of method.parameters) {
+    parameters.properties[param.name] = convertTypeToJsonSchema(param.type);
+    if (!param.optional) {
+      parameters.required.push(param.name);
+    }
+    if (param.default !== void 0) {
+      parameters.properties[param.name].default = param.default;
+    }
+  }
+  if (parameters.required.length === 0) {
+    delete parameters.required;
+  }
+  const description = config?.descriptions?.[method.name] || method.description || `Call the ${method.name} method`;
+  return {
+    type: "function",
+    function: {
+      name: method.name,
+      description,
+      parameters
+    }
+  };
+}
+function generateToolManifest(methods, config) {
+  const tools = [];
+  for (const method of methods) {
+    if (shouldIncludeMethod(method, config)) {
+      const tool = generateToolFromMethod(method, config);
+      tools.push(tool);
+    }
+  }
+  return tools;
+}
+export {
+  convertTypeToJsonSchema,
+  generateToolFromMethod,
+  generateToolManifest,
+  shouldIncludeMethod
+};
+//# sourceMappingURL=tool-generator.js.map

package/dist/tools/tool-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-generator.js","sources":["../../src/tools/tool-generator.ts"],"sourcesContent":["/**\n * Tool Manifest Generation for AI Function Calling\n *\n * This module converts TypeScript method definitions from the AST scanner\n * into AI tool format at build time for use with LLM function calling.\n */\n\nimport type { AITool } from '@happyvertical/ai';\nimport type { MethodDefinition } from '../scanner/types.js';\n\n/**\n * Configuration for AI-callable methods\n */\nexport interface AiConfig {\n  /**\n   * Methods that AI can call\n   * - Array of method names, e.g., ['analyze', 'validate']\n   * - 'public-async' to auto-include all public async methods\n   * - 'all' to include all methods (not recommended)\n   */\n  callable?: string[] | 'public-async' | 'all';\n\n  /**\n   * Methods to exclude from AI calling (higher priority than callable)\n   */\n  exclude?: string[];\n\n  /**\n   * Additional tool descriptions to override method JSDoc\n   */\n  descriptions?: Record<string, string>;\n}\n\n/**\n * Converts a TypeScript type string to JSON Schema format\n *\n * @param tsType - TypeScript type string (e.g., 'string', 'number', '{ foo: string }')\n * @returns JSON Schema representation\n */\nexport function convertTypeToJsonSchema(tsType: string): Record<string, any> {\n  // Remove whitespace\n  const cleanType = tsType.trim();\n\n  // Primitive types\n  if (cleanType === 'string') {\n    return { type: 'string' };\n  }\n  if (cleanType === 'number') {\n    return { type: 'number' };\n  }\n  if (cleanType === 'boolean') {\n    return { type: 'boolean' };\n  }\n  if (cleanType === 'null') {\n    return { type: 'null' };\n  }\n  if (cleanType === 'any' || cleanType === 'unknown') {\n    return {}; // No type constraint\n  }\n\n  // Array types\n  if (cleanType.endsWith('[]')) {\n    const itemType = cleanType.slice(0, -2);\n    return {\n      type: 'array',\n      items: convertTypeToJsonSchema(itemType),\n    };\n  }\n\n  // Array<T> syntax\n  const arrayMatch = cleanType.match(/^Array<(.+)>$/);\n  if (arrayMatch) {\n    return {\n      type: 'array',\n      items: convertTypeToJsonSchema(arrayMatch[1]),\n    };\n  }\n\n  // Union types with literal values (e.g., 'shallow' | 'deep')\n  if (cleanType.includes('|')) {\n    const options = cleanType.split('|').map((s) => s.trim());\n\n    // Check if all options are string literals\n    if (options.every((opt) => opt.startsWith(\"'\") && opt.endsWith(\"'\"))) {\n      return {\n        type: 'string',\n        enum: options.map((opt) => opt.slice(1, -1)), // Remove quotes\n      };\n    }\n\n    // Mixed union - use oneOf\n    return {\n      oneOf: options.map(convertTypeToJsonSchema),\n    };\n  }\n\n  // Object types - basic support\n  if (cleanType.startsWith('{') && cleanType.endsWith('}')) {\n    return { type: 'object' };\n  }\n\n  // Record<string, any> and similar\n  if (cleanType.startsWith('Record<')) {\n    return { type: 'object' };\n  }\n\n  // Default fallback\n  return { type: 'string', description: `TypeScript type: ${cleanType}` };\n}\n\n/**\n * Determines if a method should be included as an AI-callable tool\n *\n * @param method - Method definition from AST scanner\n * @param config - AI configuration from @smrt decorator\n * @returns True if method should be callable by AI\n */\nexport function shouldIncludeMethod(\n  method: MethodDefinition,\n  config?: AiConfig,\n): boolean {\n  // Skip if no AI config\n  if (!config || !config.callable) {\n    return false;\n  }\n\n  // Check exclusions first (higher priority)\n  if (config.exclude?.includes(method.name)) {\n    return false;\n  }\n\n  // Skip private methods always\n  if (!method.isPublic) {\n    return false;\n  }\n\n  // Skip static methods (tools operate on instances)\n  if (method.isStatic) {\n    return false;\n  }\n\n  // Handle 'all' mode\n  if (config.callable === 'all') {\n    return true;\n  }\n\n  // Handle 'public-async' mode\n  if (config.callable === 'public-async') {\n    return method.async;\n  }\n\n  // Handle explicit array of method names\n  if (Array.isArray(config.callable)) {\n    return config.callable.includes(method.name);\n  }\n\n  return false;\n}\n\n/**\n * Generates an AITool definition from a method definition\n *\n * @param method - Method definition from AST scanner\n * @param config - AI configuration for custom descriptions\n * @returns AITool definition for LLM function calling\n */\nexport function generateToolFromMethod(\n  method: MethodDefinition,\n  config?: AiConfig,\n): AITool {\n  // Build parameters JSON Schema\n  const parameters: Record<string, any> = {\n    type: 'object',\n    properties: {},\n    required: [],\n  };\n\n  for (const param of method.parameters) {\n    // Convert parameter type to JSON Schema\n    parameters.properties[param.name] = convertTypeToJsonSchema(param.type);\n\n    // Add to required if not optional\n    if (!param.optional) {\n      parameters.required.push(param.name);\n    }\n\n    // Add default value if present\n    if (param.default !== undefined) {\n      parameters.properties[param.name].default = param.default;\n    }\n  }\n\n  // Remove empty required array\n  if (parameters.required.length === 0) {\n    delete parameters.required;\n  }\n\n  // Get description (custom override or from JSDoc)\n  const description =\n    config?.descriptions?.[method.name] ||\n    method.description ||\n    `Call the ${method.name} method`;\n\n  return {\n    type: 'function',\n    function: {\n      name: method.name,\n      description,\n      parameters,\n    },\n  };\n}\n\n/**\n * Generates tool manifest from method definitions\n *\n * @param methods - Array of method definitions from AST scanner\n * @param config - AI configuration from @smrt decorator\n * @returns Array of AITool definitions for LLM function calling\n */\nexport function generateToolManifest(\n  methods: MethodDefinition[],\n  config?: AiConfig,\n): AITool[] {\n  const tools: AITool[] = [];\n\n  for (const method of methods) {\n    if (shouldIncludeMethod(method, config)) {\n      const tool = generateToolFromMethod(method, config);\n      tools.push(tool);\n    }\n  }\n\n  return tools;\n}\n"],"names":[],"mappings":"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"}

package/dist/utils/chunk.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared helpers for capping `IN (?, ?, ...)` placeholder lists so a single
+ * query never exceeds the backend's bind-variable limit.
+ *
+ * Used by the relationship/junction loaders in `collection.ts` and by the
+ * BFS frontier in `SmrtHierarchical.getDescendants()` — any code path that
+ * expands an unbounded array of ids into one `column IN (...)` clause.
+ */
+/**
+ * Maximum size of an `IN (?, ?, ...)` placeholder list per query.
+ *
+ * `SQLITE_MAX_VARIABLE_NUMBER` is 999 on SQLite builds older than 3.32 and
+ * 32766 on newer ones; Postgres allows up to 65535 bind parameters. Capping
+ * at a conservative 900 stays under the legacy SQLite limit AND keeps planner
+ * time predictable across every backend, so callers don't have to know which
+ * build they're talking to. Exceeding the cap throws
+ * `SQLITE_RANGE: bind or column index out of range` (or
+ * `SQLITE_ERROR: too many SQL variables`) before the query runs, which is why
+ * every loader that builds an IN-list from caller- or data-sized arrays must
+ * chunk through this value.
+ */
+export declare const IN_LIST_CHUNK_SIZE = 900;
+/**
+ * Split `items` into contiguous batches of at most `size` elements.
+ *
+ * - Empty input yields `[]` (no empty batch).
+ * - A non-positive `size` is treated as "no chunking" and returns a single
+ *   batch containing every item, matching the previous inline behavior in
+ *   `collection.ts`.
+ */
+export declare function chunkArray<T>(items: T[], size: number): T[][];
+//# sourceMappingURL=chunk.d.ts.map

package/dist/utils/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../src/utils/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAQ7D"}

package/dist/utils/chunk.js

@@ -0,0 +1,14 @@
+const IN_LIST_CHUNK_SIZE = 900;
+function chunkArray(items, size) {
+  if (items.length === 0) return [];
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+export {
+  IN_LIST_CHUNK_SIZE,
+  chunkArray
+};
+//# sourceMappingURL=chunk.js.map

package/dist/utils/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sources":["../../src/utils/chunk.ts"],"sourcesContent":["/**\n * Shared helpers for capping `IN (?, ?, ...)` placeholder lists so a single\n * query never exceeds the backend's bind-variable limit.\n *\n * Used by the relationship/junction loaders in `collection.ts` and by the\n * BFS frontier in `SmrtHierarchical.getDescendants()` — any code path that\n * expands an unbounded array of ids into one `column IN (...)` clause.\n */\n\n/**\n * Maximum size of an `IN (?, ?, ...)` placeholder list per query.\n *\n * `SQLITE_MAX_VARIABLE_NUMBER` is 999 on SQLite builds older than 3.32 and\n * 32766 on newer ones; Postgres allows up to 65535 bind parameters. Capping\n * at a conservative 900 stays under the legacy SQLite limit AND keeps planner\n * time predictable across every backend, so callers don't have to know which\n * build they're talking to. Exceeding the cap throws\n * `SQLITE_RANGE: bind or column index out of range` (or\n * `SQLITE_ERROR: too many SQL variables`) before the query runs, which is why\n * every loader that builds an IN-list from caller- or data-sized arrays must\n * chunk through this value.\n */\nexport const IN_LIST_CHUNK_SIZE = 900;\n\n/**\n * Split `items` into contiguous batches of at most `size` elements.\n *\n * - Empty input yields `[]` (no empty batch).\n * - A non-positive `size` is treated as \"no chunking\" and returns a single\n *   batch containing every item, matching the previous inline behavior in\n *   `collection.ts`.\n */\nexport function chunkArray<T>(items: T[], size: number): T[][] {\n  if (items.length === 0) return [];\n  if (size <= 0) return [items];\n  const chunks: T[][] = [];\n  for (let i = 0; i < items.length; i += size) {\n    chunks.push(items.slice(i, i + size));\n  }\n  return chunks;\n}\n"],"names":[],"mappings":"AAsBO,MAAM,qBAAqB;AAU3B,SAAS,WAAc,OAAY,MAAqB;AAC7D,MAAI,MAAM,WAAW,EAAG,QAAO,CAAA;AAE/B,QAAM,SAAgB,CAAA;AACtB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,MAAM;AAC3C,WAAO,KAAK,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC;AAAA,EACtC;AACA,SAAO;AACT;"}

package/dist/utils/import-workspace-module.d.ts

@@ -0,0 +1,8 @@
+export interface ImportWorkspaceModuleOptions {
+    packageName: string;
+    sourceEntry: string;
+    distEntry?: string;
+    purpose: string;
+}
+export declare function importWorkspaceModule<T = unknown>({ packageName, sourceEntry, distEntry, purpose, }: ImportWorkspaceModuleOptions): Promise<T>;
+//# sourceMappingURL=import-workspace-module.d.ts.map

package/dist/utils/import-workspace-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-workspace-module.d.ts","sourceRoot":"","sources":["../../src/utils/import-workspace-module.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,4BAA4B;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAsBD,wBAAsB,qBAAqB,CAAC,CAAC,GAAG,OAAO,EAAE,EACvD,WAAW,EACX,WAAW,EACX,SAAS,EACT,OAAO,GACR,EAAE,4BAA4B,GAAG,OAAO,CAAC,CAAC,CAAC,CAmD3C"}

package/dist/utils/import-workspace-module.js

@@ -0,0 +1,81 @@
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+function findWorkspaceRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    if (existsSync(join(current, "pnpm-workspace.yaml"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveInstalledPackage(packageName) {
+  return import.meta.resolve(packageName);
+}
+async function importWorkspaceModule({
+  packageName,
+  sourceEntry,
+  distEntry,
+  purpose
+}) {
+  try {
+    return await import(
+      /* @vite-ignore */
+      resolveInstalledPackage(packageName)
+    );
+  } catch (originalError) {
+    const workspaceRoot = findWorkspaceRoot(process.cwd());
+    if (!workspaceRoot) {
+      throw originalError;
+    }
+    if (distEntry) {
+      const distPath = join(workspaceRoot, distEntry);
+      if (existsSync(distPath)) {
+        return await import(
+          /* @vite-ignore */
+          pathToFileURL(distPath).href
+        );
+      }
+    }
+    const sourcePath = join(workspaceRoot, sourceEntry);
+    if (!existsSync(sourcePath)) {
+      throw new Error(
+        `Failed to load ${packageName} for ${purpose}: could not find ${sourcePath}.`
+      );
+    }
+    let tsxApiPath;
+    try {
+      tsxApiPath = import.meta.resolve("tsx/esm/api");
+    } catch (tsxError) {
+      throw new Error(
+        `Failed to load ${packageName} for ${purpose}: workspace source fallback requires the "tsx" package.`,
+        { cause: tsxError }
+      );
+    }
+    const { register } = await import(
+      /* @vite-ignore */
+      tsxApiPath
+    );
+    const tsconfigPath = join(workspaceRoot, "tsconfig.package-build.json");
+    const unregister = register(
+      existsSync(tsconfigPath) ? { tsconfig: tsconfigPath } : void 0
+    );
+    try {
+      return await import(
+        /* @vite-ignore */
+        pathToFileURL(sourcePath).href
+      );
+    } finally {
+      await unregister();
+    }
+  }
+}
+export {
+  importWorkspaceModule
+};
+//# sourceMappingURL=import-workspace-module.js.map

package/dist/utils/import-workspace-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-workspace-module.js","sources":["../../src/utils/import-workspace-module.ts"],"sourcesContent":["import { existsSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { pathToFileURL } from 'node:url';\n\nexport interface ImportWorkspaceModuleOptions {\n  packageName: string;\n  sourceEntry: string;\n  distEntry?: string;\n  purpose: string;\n}\n\nfunction findWorkspaceRoot(startDir: string): string | null {\n  let current = startDir;\n\n  while (true) {\n    if (existsSync(join(current, 'pnpm-workspace.yaml'))) {\n      return current;\n    }\n\n    const parent = dirname(current);\n    if (parent === current) {\n      return null;\n    }\n    current = parent;\n  }\n}\n\nfunction resolveInstalledPackage(packageName: string): string {\n  return import.meta.resolve(packageName);\n}\n\nexport async function importWorkspaceModule<T = unknown>({\n  packageName,\n  sourceEntry,\n  distEntry,\n  purpose,\n}: ImportWorkspaceModuleOptions): Promise<T> {\n  try {\n    return (await import(\n      /* @vite-ignore */ resolveInstalledPackage(packageName)\n    )) as T;\n  } catch (originalError) {\n    const workspaceRoot = findWorkspaceRoot(process.cwd());\n    if (!workspaceRoot) {\n      throw originalError;\n    }\n\n    if (distEntry) {\n      const distPath = join(workspaceRoot, distEntry);\n      if (existsSync(distPath)) {\n        return (await import(\n          /* @vite-ignore */ pathToFileURL(distPath).href\n        )) as T;\n      }\n    }\n\n    const sourcePath = join(workspaceRoot, sourceEntry);\n    if (!existsSync(sourcePath)) {\n      throw new Error(\n        `Failed to load ${packageName} for ${purpose}: could not find ${sourcePath}.`,\n      );\n    }\n\n    let tsxApiPath: string;\n    try {\n      tsxApiPath = import.meta.resolve('tsx/esm/api');\n    } catch (tsxError) {\n      throw new Error(\n        `Failed to load ${packageName} for ${purpose}: workspace source fallback requires the \"tsx\" package.`,\n        { cause: tsxError },\n      );\n    }\n\n    const { register } = await import(/* @vite-ignore */ tsxApiPath);\n    const tsconfigPath = join(workspaceRoot, 'tsconfig.package-build.json');\n    const unregister = register(\n      existsSync(tsconfigPath) ? { tsconfig: tsconfigPath } : undefined,\n    );\n\n    try {\n      return (await import(\n        /* @vite-ignore */ pathToFileURL(sourcePath).href\n      )) as T;\n    } finally {\n      await unregister();\n    }\n  }\n}\n"],"names":[],"mappings":";;;AAWA,SAAS,kBAAkB,UAAiC;AAC1D,MAAI,UAAU;AAEd,SAAO,MAAM;AACX,QAAI,WAAW,KAAK,SAAS,qBAAqB,CAAC,GAAG;AACpD,aAAO;AAAA,IACT;AAEA,UAAM,SAAS,QAAQ,OAAO;AAC9B,QAAI,WAAW,SAAS;AACtB,aAAO;AAAA,IACT;AACA,cAAU;AAAA,EACZ;AACF;AAEA,SAAS,wBAAwB,aAA6B;AAC5D,SAAO,YAAY,QAAQ,WAAW;AACxC;AAEA,eAAsB,sBAAmC;AAAA,EACvD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA6C;AAC3C,MAAI;AACF,WAAQ,MAAM;AAAA;AAAA,MACO,wBAAwB,WAAW;AAAA;AAAA,EAE1D,SAAS,eAAe;AACtB,UAAM,gBAAgB,kBAAkB,QAAQ,IAAA,CAAK;AACrD,QAAI,CAAC,eAAe;AAClB,YAAM;AAAA,IACR;AAEA,QAAI,WAAW;AACb,YAAM,WAAW,KAAK,eAAe,SAAS;AAC9C,UAAI,WAAW,QAAQ,GAAG;AACxB,eAAQ,MAAM;AAAA;AAAA,UACO,cAAc,QAAQ,EAAE;AAAA;AAAA,MAE/C;AAAA,IACF;AAEA,UAAM,aAAa,KAAK,eAAe,WAAW;AAClD,QAAI,CAAC,WAAW,UAAU,GAAG;AAC3B,YAAM,IAAI;AAAA,QACR,kBAAkB,WAAW,QAAQ,OAAO,oBAAoB,UAAU;AAAA,MAAA;AAAA,IAE9E;AAEA,QAAI;AACJ,QAAI;AACF,mBAAa,YAAY,QAAQ,aAAa;AAAA,IAChD,SAAS,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,kBAAkB,WAAW,QAAQ,OAAO;AAAA,QAC5C,EAAE,OAAO,SAAA;AAAA,MAAS;AAAA,IAEtB;AAEA,UAAM,EAAE,SAAA,IAAa,MAAM;AAAA;AAAA,MAA0B;AAAA;AACrD,UAAM,eAAe,KAAK,eAAe,6BAA6B;AACtE,UAAM,aAAa;AAAA,MACjB,WAAW,YAAY,IAAI,EAAE,UAAU,iBAAiB;AAAA,IAAA;AAG1D,QAAI;AACF,aAAQ,MAAM;AAAA;AAAA,QACO,cAAc,UAAU,EAAE;AAAA;AAAA,IAEjD,UAAA;AACE,YAAM,WAAA;AAAA,IACR;AAAA,EACF;AACF;"}

package/dist/utils/json.d.ts

@@ -0,0 +1,102 @@
+import { JSONAdapter, ParseError, Result, StringifyError } from '@happyvertical/json';
+/**
+ * Parse JSON string with optional SIMD acceleration
+ *
+ * @example
+ * ```typescript
+ * import { parse } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const data = parse<MyType>('{"key": "value"}');
+ * ```
+ */
+export declare function parse<T = unknown>(text: string): T;
+/**
+ * Stringify value to JSON with optional SIMD acceleration
+ *
+ * @example
+ * ```typescript
+ * import { stringify } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const json = stringify({ key: 'value' });
+ * const pretty = stringify({ key: 'value' }, null, 2);
+ * ```
+ */
+export declare function stringify(value: unknown, replacer?: ((key: string, value: unknown) => unknown) | (string | number)[] | null, space?: number | string): string;
+/**
+ * Deep clone via JSON round-trip with optional SIMD acceleration
+ *
+ * @example
+ * ```typescript
+ * import { clone } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const copy = clone(original);
+ * ```
+ */
+export declare function clone<T>(value: T): T;
+/**
+ * Parse JSON without throwing - returns Result type
+ *
+ * @example
+ * ```typescript
+ * import { safeParse } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const result = safeParse<Config>(configJson);
+ * if (result.success) {
+ *   console.log(result.value);
+ * } else {
+ *   console.error(result.error.message);
+ * }
+ * ```
+ */
+export declare function safeParse<T = unknown>(text: string): Result<T, ParseError>;
+/**
+ * Stringify without throwing - returns Result type
+ *
+ * @example
+ * ```typescript
+ * import { safeStringify } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const result = safeStringify(data);
+ * if (result.success) {
+ *   console.log(result.value);
+ * } else {
+ *   console.error(result.error.message);
+ * }
+ * ```
+ */
+export declare function safeStringify(value: unknown): Result<string, StringifyError>;
+/**
+ * Check if a string is valid JSON
+ *
+ * @example
+ * ```typescript
+ * import { isValid } from '@happyvertical/smrt-core/utils/json';
+ *
+ * if (isValid(userInput)) {
+ *   // Safe to parse
+ * }
+ * ```
+ */
+export declare function isValid(text: string): boolean;
+/**
+ * Get information about the active JSON adapter
+ *
+ * @example
+ * ```typescript
+ * import { getAdapterInfo } from '@happyvertical/smrt-core/utils/json';
+ *
+ * const info = getAdapterInfo();
+ * console.log(`Using ${info.name} adapter, SIMD: ${info.simdEnabled}`);
+ * ```
+ */
+export declare function getAdapterInfo(): {
+    name: string;
+    isNative: boolean;
+    version?: string;
+    simdEnabled?: boolean;
+};
+/**
+ * Re-export types for convenience
+ */
+export type { JSONAdapter, ParseError, Result, StringifyError };
+//# sourceMappingURL=json.d.ts.map

package/dist/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/utils/json.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAkB7B;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAElD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EACL,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,GAC1C,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GACnB,IAAI,EACR,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,CAER;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEpC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAE1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAE5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAEA;AAED;;GAEG;AACH,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC"}