@amitdeshmukh/ax-crew 5.0.0 → 7.0.0

package/examples/telemetry-demo.ts

@@ -0,0 +1,166 @@
+
+import { AxCrew } from "../dist/index.js";
+import { AxCrewFunctions } from "../dist/functions/index.js";
+import type { AxCrewConfig } from "../dist/types.js";
+import type { Provider } from "../dist/types.js";
+import "dotenv/config";
+
+// Import OpenTelemetry packages
+// Note: In a real project, you would need to install these dependencies:
+// npm install @opentelemetry/api @opentelemetry/sdk-trace-node @opentelemetry/sdk-metrics
+// Optional: npm install @opentelemetry/exporter-jaeger (for Jaeger UI visualization)
+import { metrics, trace } from "@opentelemetry/api";
+import {
+  ConsoleSpanExporter,
+  SimpleSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+  ConsoleMetricExporter,
+  MeterProvider,
+  PeriodicExportingMetricReader,
+} from "@opentelemetry/sdk-metrics";
+
+// Optional Jaeger import - will be used if available
+let JaegerExporter;
+try {
+  JaegerExporter = (await import('@opentelemetry/exporter-jaeger')).JaegerExporter;
+} catch (error) {
+  console.log('Jaeger exporter not available. Install with: npm install @opentelemetry/exporter-jaeger');
+  console.log('Traces will only be sent to console.');
+}
+
+// --- 1. Setup OpenTelemetry (Console + Optional Jaeger) ---
+
+// Set up tracing to console and optionally Jaeger
+const spanProcessors = [new SimpleSpanProcessor(new ConsoleSpanExporter())];
+
+// Add Jaeger if available
+if (JaegerExporter) {
+  try {
+    spanProcessors.push(new SimpleSpanProcessor(new JaegerExporter({
+      endpoint: 'http://localhost:14268/api/traces',
+    })));
+    console.log('Jaeger tracing enabled. View traces at: http://localhost:16686');
+  } catch (error) {
+    console.log('Failed to initialize Jaeger exporter:', error.message);
+    console.log('Continuing with console tracing only.');
+  }
+}
+
+const tracerProvider = new NodeTracerProvider({
+  spanProcessors
+});
+tracerProvider.register(); // This registers it as the global tracer provider
+
+// Set up basic metrics to print to console
+const meterProvider = new MeterProvider({
+  readers: [
+    new PeriodicExportingMetricReader({
+      exporter: new ConsoleMetricExporter(),
+      exportIntervalMillis: 5000, // Export every 5 seconds
+    }),
+  ],
+});
+metrics.setGlobalMeterProvider(meterProvider);
+
+// Get your tracer and meter instances
+const tracer = trace.getTracer("ax-crew-example");
+const meter = metrics.getMeter("ax-crew-example");
+
+// --- 2. Define Crew Configuration ---
+
+const crewConfig: AxCrewConfig = {
+  crew: [
+    {
+      name: "Researcher",
+      description: "Researches a topic using tools and provides a summary.",
+      signature: "topic:string -> facts:string[]",
+      // Agent 1 uses OpenAI
+      provider: "openai" as Provider,
+      providerKeyName: "OPENAI_API_KEY",
+      ai: {
+        model: "gpt-4o-mini",
+        temperature: 0.7,
+      },
+      // Give this agent access to a tool (function)
+      functions: ["CurrentDateTime"]
+    },
+    {
+      name: "Writer",
+      description: "Writes a blog post based on provided facts.",
+      signature: "facts:string[] -> blogPost:string",
+      // Agent 2 uses a different provider (e.g., Google Gemini)
+      provider: "google-gemini" as Provider,
+      providerKeyName: "GEMINI_API_KEY",
+      ai: {
+        model: "gemini-flash-latest",
+        temperature: 0.7,
+      },
+      // No tools for this agent, just pure generation
+    }
+  ]
+};
+
+// --- 3. Run the Crew ---
+
+async function main() {
+  console.log("Starting AxCrew with Telemetry...");
+
+  // Initialize AxCrew with the telemetry options
+  const crew = new AxCrew(
+    crewConfig,
+    AxCrewFunctions,
+    undefined, // Use default crewId
+    {
+      telemetry: {
+        tracer,
+        meter
+      }
+    }
+  );
+
+  try {
+    // Initialize agents
+    await crew.addAgent("Researcher");
+    await crew.addAgent("Writer");
+
+    const researcher = crew.agents!.get("Researcher")!;
+    const writer = crew.agents!.get("Writer")!;
+
+    // Step 1: Research
+    console.log("\n--- Step 1: Researching ---");
+    // This call will be traced, including the 'CurrentDateTime' tool usage
+    const researchResult = await researcher.forward({
+      topic: "The future of AI agents in 2025"
+    });
+    console.log("Research output:", researchResult.facts);
+
+    // Step 2: Writing
+    console.log("\n--- Step 2: Writing ---");
+    // This call will be traced under a different provider
+    const writerResult = await writer.forward({
+      facts: researchResult.facts
+    });
+    console.log("Blog Post:\n", writerResult.blogPost);
+
+    console.log("\n--- Done ---");
+    console.log("Check your console output above for OpenTelemetry traces and metrics.");
+    if (JaegerExporter) {
+      console.log("Check Jaeger UI at http://localhost:16686 for enhanced trace visualization.");
+    } else {
+      console.log("For enhanced visualization, install Jaeger: npm install @opentelemetry/exporter-jaeger");
+      console.log("Then run: docker run -d --name jaeger -p 16686:16686 -p 14268:14268 jaegertracing/all-in-one:latest");
+    }
+
+    // Wait a moment for metrics to export before exiting
+    await new Promise(resolve => setTimeout(resolve, 6000));
+
+  } catch (error) {
+    console.error("Error running crew:", error);
+  } finally {
+    crew.destroy();
+  }
+}
+
+main().catch(console.error);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@amitdeshmukh/ax-crew",
-  "version": "5.0.0",
+  "version": "7.0.0",
   "description": "Build and launch a crew of AI agents with shared state. Built with axllm.dev",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,7 +11,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc --outDir dist",
     "release": "npm run build && npm publish --access public",
-    "test": "vitest",
+    "test": "vitest run",
     "test:watch": "vitest watch",
     "test:coverage": "vitest run --coverage",
     "test:ui": "vitest --ui"
@@ -24,8 +24,9 @@
     "uuid": "^10.0.0"
   },
   "peerDependencies": {
-    "@ax-llm/ax": "14.0.16",
-    "@ax-llm/ax-tools": "14.0.16"
+    "@ax-llm/ax": "^14.0.36",
+    "@ax-llm/ax-tools": "^14.0.36",
+    "@opentelemetry/api": "^1.9.0"
   },
   "devDependencies": {
     "@testing-library/jest-dom": "^6.6.3",

package/src/agents/agentConfig.ts

@@ -1,20 +1,13 @@
-import fs from 'fs';
-// Import Ax factory and MCP transports (as exported by current package)
+// Import Ax factory and MCP transports
 import { ai, AxMCPClient, AxMCPHTTPSSETransport, AxMCPStreambleHTTPTransport, AxDefaultCostTracker } from '@ax-llm/ax'
-import type {
-  AxAIAzureOpenAIArgs,
-  AxAIAnthropicArgs,
-  AxAIGoogleGeminiArgs,
-  AxAIOpenRouterArgs,
-  AxAIOllamaArgs
-} from '@ax-llm/ax';
 import type { AxFunction } from '@ax-llm/ax';
 // STDIO transport from tools package
 import { AxMCPStdioTransport } from '@ax-llm/ax-tools'
-import { PROVIDER_API_KEYS } from '../config/index.js';
+// Resolve env by provided key name
 import type { 
   AgentConfig,
-  CrewConfigInput,
+  AxCrewConfig,
+  AxCrewOptions,
   FunctionRegistryType, 
   MCPTransportConfig, 
   MCPStdioTransportConfig, 
@@ -23,26 +16,6 @@ import type {
 } from '../types.js';
 import type { Provider } from '../types.js';
 
-// Canonical provider slugs supported by ai() factory
-const PROVIDER_CANONICAL = new Set([
-  'openai',
-  'anthropic',
-  'google-gemini',
-  'mistral',
-  'groq',
-  'cohere',
-  'together',
-  'deepseek',
-  'ollama',
-  'huggingface',
-  'openrouter',
-  'azure-openai',
-  'reka',
-  'x-grok'
-]);
-
-// Provider type lives in src/types.ts
-
 // Type guard to check if config is stdio transport
 export function isStdioTransport(config: MCPTransportConfig): config is MCPStdioTransportConfig {
   return 'command' in config;
@@ -69,53 +42,7 @@ function isConstructor<T>(func: any): func is { new (...args: any[]): T } {
   return typeof func === 'function' && 'prototype' in func && 'toFunction' in func.prototype;
 }
 
-/**
- * Provides a user-friendly error message for JSON parsing errors
- */
-const getFormattedJSONError = (error: Error, fileContents: string): string => {
-  if (error instanceof SyntaxError) {
-    const match = error.message.match(/position (\d+)/);
-    const position = match ? parseInt(match[1]) : -1;
-    
-    if (position !== -1) {
-      const lines = fileContents.split('\n');
-      let currentPos = 0;
-      let errorLine = 0;
-      let errorColumn = 0;
-
-      // Find the line and column of the error
-      for (let i = 0; i < lines.length; i++) {
-        if (currentPos + lines[i].length >= position) {
-          errorLine = i + 1;
-          errorColumn = position - currentPos + 1;
-          break;
-        }
-        currentPos += lines[i].length + 1; // +1 for the newline character
-      }
-
-      const contextLines = lines.slice(Math.max(0, errorLine - 3), errorLine + 2)
-        .map((line, idx) => `${errorLine - 2 + idx}:  ${line}`).join('\n');
-
-      return `JSON Parse Error in your agent configuration:
-      
-Error near line ${errorLine}, column ${errorColumn}
-
-Context:
-${contextLines}
-
-Common issues to check:
-- Missing or extra commas between properties
-- Missing quotes around property names
-- Unmatched brackets or braces
-- Invalid JSON values
-- Trailing commas (not allowed in JSON)
-
-Original error: ${error.message}`;
-    }
-  }
-  
-  return `Error parsing agent configuration: ${error.message}`;
-};
+// Removed file/JSON parse helpers to keep browser-safe
 
 const initializeMCPServers = async (agentConfigData: AgentConfig): Promise<AxFunction[]> => {
   const mcpServers = agentConfigData.mcpServers;
@@ -158,32 +85,16 @@ const initializeMCPServers = async (agentConfigData: AgentConfig): Promise<AxFun
 };
 
 /**
- * Parses and returns the AxCrew config from either a JSON config file or a direct JSON object.
- * @param {CrewConfigInput} input - Either a path to the agent config json file or a JSON object with crew configuration.
+ * Returns the AxCrew config from a direct JSON object. Browser-safe.
+ * @param {CrewConfig} input - A JSON object with crew configuration.
  * @returns {Object} The parsed crew config.
  * @throws Will throw an error if reading/parsing fails.
  */
-const parseCrewConfig = (input: CrewConfigInput): { crew: AgentConfig[] } => {
-  try {
-    if (typeof input === 'string') {
-      // Handle file path input
-      const fileContents = fs.readFileSync(input, 'utf8');
-      const parsedConfig = JSON.parse(fileContents) as { crew: AgentConfig[] };
-      return parsedConfig;
-    } else {
-      // Handle direct JSON object input
-      return input;
-    }
-  } catch (e) {
-    if (e instanceof Error) {
-      if (typeof input === 'string') {
-        const formattedError = getFormattedJSONError(e, fs.readFileSync(input, 'utf8'));
-        throw new Error(formattedError);
-      }
-      throw new Error(`Error parsing agent configuration: ${e.message}`);
-    }
-    throw e;
+const parseCrewConfig = (input: AxCrewConfig): { crew: AgentConfig[] } => {
+  if (!input || typeof input !== 'object' || !Array.isArray((input as any).crew)) {
+    throw new Error('Invalid crew configuration: expected an object with a crew array');
   }
+  return input as { crew: AgentConfig[] };
 };
 
 /**
@@ -191,7 +102,7 @@ const parseCrewConfig = (input: CrewConfigInput): { crew: AgentConfig[] } => {
  * and creates an instance of the Agent with the appropriate settings.
  *
  * @param {string} agentName - The identifier for the AI agent to be initialized.
- * @param {CrewConfigInput} crewConfig - Either a file path to the JSON configuration or a JSON object with crew configuration.
+ * @param {AxCrewConfig} crewConfig - A JSON object with crew configuration.
  * @param {FunctionRegistryType} functions - The functions available to the agent.
  * @param {Object} state - The state object for the agent.
  * @returns {Object} An object containing the Agents AI instance, its name, description, signature, functions and subAgentList.
@@ -200,9 +111,10 @@ const parseCrewConfig = (input: CrewConfigInput): { crew: AgentConfig[] } => {
  */
 const parseAgentConfig = async (
   agentName: string, 
-  crewConfig: CrewConfigInput,
+  crewConfig: AxCrewConfig,
   functions: FunctionRegistryType,
-  state: Record<string, any>
+  state: Record<string, any>,
+  options?: AxCrewOptions
 ) => {
   try {
     // Retrieve the parameters for the specified AI agent from config
@@ -211,20 +123,17 @@ const parseAgentConfig = async (
       throw new Error(`AI agent with name ${agentName} is not configured`);
     }
 
-    // Enforce canonical provider slug
-    const lower = agentConfigData.provider.toLowerCase();
-    if (!PROVIDER_CANONICAL.has(lower)) {
-      throw new Error(`AI provider ${agentConfigData.provider} is not supported. Use one of: ${Array.from(PROVIDER_CANONICAL).join(', ')}`);
-    }
+    // Normalize provider slug to lowercase and validate via Ax factory
+    const lower = String(agentConfigData.provider).toLowerCase() as Provider;
     const provider = lower as Provider;
 
-    // If an API Key property is present, get the API key for the AI agent from the environment variables
+    // Resolve API key from user-supplied environment variable name
     let apiKey = '';
     if (agentConfigData.providerKeyName) {
-      apiKey = PROVIDER_API_KEYS[agentConfigData.providerKeyName] || '';
-
+      const keyName = agentConfigData.providerKeyName;
+      apiKey = resolveApiKey(keyName) || '';
       if (!apiKey) {
-        throw new Error(`API key for provider ${agentConfigData.provider} is not set in environment variables`);
+        throw new Error(`API key '${keyName}' for provider ${agentConfigData.provider} is not set in environment`);
       }
     } else {
       throw new Error(`Provider key name is missing in the agent configuration`);
@@ -242,7 +151,10 @@ const parseAgentConfig = async (
         debug: agentConfigData.debug || false,
         ...agentConfigData.options,
         // Attach default cost tracker so usage/costs are recorded by provider layer
-        trackers: [costTracker]
+        trackers: [costTracker],
+        // Inject telemetry if provided
+        tracer: options?.telemetry?.tracer,
+        meter: options?.telemetry?.meter
       }
     };
     if (agentConfigData.apiURL) {
@@ -253,37 +165,19 @@ const parseAgentConfig = async (
         throw new Error(`Invalid apiURL provided: ${agentConfigData.apiURL}`);
       }
     }
-    // Forward provider-specific arguments with type-safety for Azure OpenAI
+    // Forward provider-specific arguments as-is; let Ax validate/ignore as needed
     const providerArgs = (agentConfigData as any).providerArgs;
-    if (provider === 'azure-openai') {
-      type AzureArgs = Pick<AxAIAzureOpenAIArgs<string>, 'resourceName' | 'deploymentName' | 'version'>;
-      const az: Partial<AzureArgs> = providerArgs ?? {};
-      // If users supplied apiURL instead of resourceName, accept it (Ax supports full URL as resourceName)
-      if (!az.resourceName && agentConfigData.apiURL) {
-        az.resourceName = agentConfigData.apiURL as any;
-      }
-      Object.assign(aiArgs, az);
-    } else if (provider === 'anthropic') {
-      type AnthropicArgs = Pick<AxAIAnthropicArgs<string>, 'projectId' | 'region'>;
-      const an: Partial<AnthropicArgs> = providerArgs ?? {};
-      Object.assign(aiArgs, an);
-    } else if (provider === 'google-gemini') {
-      type GeminiArgs = Pick<AxAIGoogleGeminiArgs<string>, 'projectId' | 'region' | 'endpointId'>;
-      const g: Partial<GeminiArgs> = providerArgs ?? {};
-      Object.assign(aiArgs, g);
-    } else if (provider === 'openrouter') {
-      type OpenRouterArgs = Pick<AxAIOpenRouterArgs<string>, 'referer' | 'title'>;
-      const o: Partial<OpenRouterArgs> = providerArgs ?? {};
-      Object.assign(aiArgs, o);
-    } else if (provider === 'ollama') {
-      type OllamaArgs = Pick<AxAIOllamaArgs<string>, 'url'>;
-      const ol: Partial<OllamaArgs> = providerArgs ?? {};
-      Object.assign(aiArgs, ol);
-    } else if (providerArgs && typeof providerArgs === 'object') {
-      // Generic pass-through for other providers if needed in the future
+    if (providerArgs && typeof providerArgs === 'object') {
       Object.assign(aiArgs, providerArgs);
     }
-    const aiInstance = ai(aiArgs);
+    // Validate provider by attempting instantiation; Ax will throw on unknown providers
+    let aiInstance;
+    try {
+      aiInstance = ai(aiArgs);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`Unsupported provider '${provider}': ${msg}`);
+    }
 
     // If an mcpServers config is provided in the agent config, convert to functions
     const mcpFunctions = await initializeMCPServers(agentConfigData);
@@ -328,4 +222,21 @@ const parseAgentConfig = async (
 export { 
   parseAgentConfig,
   parseCrewConfig
-};
+};
+
+function resolveApiKey(varName: string): string | undefined {
+  try {
+    // Prefer Node env when available
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    if (typeof process !== 'undefined' && process?.env) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return process.env[varName];
+    }
+    // Fallback: allow global exposure in browser builds (e.g., injected at runtime)
+    return (globalThis as any)?.[varName];
+  } catch {
+    return undefined;
+  }
+}

package/src/agents/compose.ts

@@ -0,0 +1,80 @@
+import { ai } from '@ax-llm/ax';
+import type { AxAI } from '@ax-llm/ax';
+import type { AxCrewConfig } from '../types.js';
+
+type BuildProviderArgs = {
+  provider: string;
+  apiKey: string;
+  config: any;
+  apiURL?: string;
+  providerArgs?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+};
+
+export function instantiateProvider({
+  provider,
+  apiKey,
+  config,
+  apiURL,
+  providerArgs,
+  options,
+}: BuildProviderArgs): AxAI<any> {
+  const args: any = { name: provider as any, apiKey, config, options };
+  if (apiURL) args.apiURL = apiURL;
+  if (providerArgs && typeof providerArgs === 'object') Object.assign(args, providerArgs);
+  return ai(args) as unknown as AxAI<any>;
+}
+
+export function buildProvidersFromConfig(cfg: AxCrewConfig): AxAI<any>[] {
+  const services: AxAI<any>[] = [];
+  for (const agent of cfg.crew) {
+    const apiKeyName = agent.providerKeyName;
+    if (!apiKeyName) throw new Error(`Provider key name is missing for agent ${agent.name}`);
+    const apiKey = resolveApiKey(apiKeyName) || '';
+    if (!apiKey) throw new Error(`API key '${apiKeyName}' not set for agent ${agent.name}`);
+
+    const service = instantiateProvider({
+      provider: String(agent.provider).toLowerCase(),
+      apiKey,
+      config: agent.ai,
+      apiURL: agent.apiURL,
+      providerArgs: (agent as any).providerArgs,
+      options: agent.options,
+    });
+    services.push(service);
+  }
+  return services;
+}
+
+
+// Provider discovery helpers consolidated here (previously in src/providers.ts)
+export function discoverProvidersFromConfig(cfg: AxCrewConfig): string[] {
+  const providers = new Set<string>();
+  for (const agent of cfg.crew) {
+    providers.add(String(agent.provider).toLowerCase());
+  }
+  return Array.from(providers);
+}
+
+export function listSelectableProviders(cfg: AxCrewConfig): string[] {
+  return discoverProvidersFromConfig(cfg);
+}
+
+function resolveApiKey(varName: string): string | undefined {
+  try {
+    // Prefer Node env when available
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    if (typeof process !== 'undefined' && process?.env) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return process.env[varName];
+    }
+    // Fallback: allow global exposure in browser builds (e.g., injected at runtime)
+    return (globalThis as any)?.[varName];
+  } catch {
+    return undefined;
+  }
+}
+
+

package/src/agents/index.ts

@@ -14,7 +14,8 @@ import type {
    StateInstance, 
    FunctionRegistryType, 
    UsageCost, 
-   CrewConfigInput, 
+   AxCrewConfig,
+   AxCrewOptions,
    MCPTransportConfig,
 } from "../types.js";
 
@@ -260,10 +261,27 @@ class StatefulAxAgent extends AxAgent<any, any> {
 }
 
 /**
- * Represents a crew of agents with shared state functionality.
+ * AxCrew orchestrates a set of Ax agents that share state,
+ * tools (functions), optional MCP servers, streaming, and a built-in metrics
+ * registry for tokens, requests, and estimated cost.
+ *
+ * Typical usage:
+ *  const crew = new AxCrew(config, AxCrewFunctions)
+ *  await crew.addAllAgents()
+ *  const planner = crew.agents?.get("Planner")
+ *  const res = await planner?.forward({ task: "Plan something" })
+ *
+ * Key behaviors:
+ * - Validates and instantiates agents from a config-first model
+ * - Shares a mutable state object across all agents in the crew
+ * - Supports sub-agents and a function registry per agent
+ * - Tracks per-agent and crew-level metrics via MetricsRegistry
+ * - Provides helpers to add agents (individually, a subset, or all) and
+ *   to reset metrics/costs when needed
  */
 class AxCrew {
-  private crewConfig: CrewConfigInput;
+  private crewConfig: AxCrewConfig;
+  private options?: AxCrewOptions;
   functionsRegistry: FunctionRegistryType = {};
   crewId: string;
   agents: Map<string, StatefulAxAgent> | null;
@@ -271,14 +289,16 @@ class AxCrew {
 
   /**
    * Creates an instance of AxCrew.
-   * @param {CrewConfigInput} crewConfig - Either a path to the agent config file or a JSON object with crew configuration.
+   * @param {AxCrewConfig} crewConfig - JSON object with crew configuration.
    * @param {FunctionRegistryType} [functionsRegistry={}] - The registry of functions to use in the crew.
+   * @param {AxCrewOptions} [options] - Optional settings for the crew (e.g., telemetry).
    * @param {string} [crewId=uuidv4()] - The unique identifier for the crew.
    */
   constructor(
-    crewConfig: CrewConfigInput,
+    crewConfig: AxCrewConfig,
     functionsRegistry: FunctionRegistryType = {},
-    crewId: string = uuidv4()
+    options?: AxCrewOptions,
+    crewId: string = uuidv4(),
   ) {
     // Basic validation of crew configuration
     if (!crewConfig || typeof crewConfig !== 'object' || !('crew' in crewConfig)) {
@@ -286,7 +306,7 @@ class AxCrew {
     }
 
     // Validate each agent in the crew
-    crewConfig.crew.forEach(agent => {
+    crewConfig.crew.forEach((agent: any) => {
       if (!agent.name || agent.name.trim() === '') {
         throw new Error('Agent name cannot be empty');
       }
@@ -295,6 +315,7 @@ class AxCrew {
     this.crewConfig = crewConfig;
     this.functionsRegistry = functionsRegistry;
     this.crewId = crewId;
+    this.options = options;
     this.agents = new Map<string, StatefulAxAgent>();
     this.state = createState(crewId);
     // Make crewId discoverable to metrics
@@ -313,7 +334,8 @@ class AxCrew {
         agentName,
         this.crewConfig,
         this.functionsRegistry,
-        this.state
+        this.state,
+        this.options
       );
 
       // Destructure with type assertion

package/src/functions/index.ts

@@ -1,6 +1,16 @@
 import { CurrentDateTime, DaysBetweenDates } from './dateTime.js';
 
-// Built-in functions
+/**
+ * Built-in function registry for AxCrew agents.
+ *
+ * Contains common utility tools/functions that can be referenced by name from
+ * agent configs (e.g., "functions": ["CurrentDateTime", "DaysBetweenDates"]).
+ * You can pass this object to the AxCrew constructor or merge with your
+ * own registry.
+ * Example:
+ * const crew = new AxCrew(config, AxCrewFunctions); or
+ * const crew = new AxCrew(config, { ...AxCrewFunctions, ...myFunctions });
+ */
 const AxCrewFunctions = {
   CurrentDateTime,
   DaysBetweenDates