@amitdeshmukh/ax-crew 3.6.1 → 3.7.1

package/.env.example

@@ -0,0 +1,9 @@
+# API Keys (only set the ones you need)
+OPENAI_API_KEY=sk-******************BlLB
+ANTHROPIC_API_KEY=sk-ant-api********cQAA
+GEMINI_API_KEY=sk-gemini-api********cQAA
+COHERE_API_KEY=sk-cohere-api********cQAA
+MISTRAL_API_KEY=sk-mistral-api********cQAA
+GROK_API_KEY=sk-grok-api********cQAA
+TOGETHER_API_KEY=sk-together-api********cQAA
+HUGGINGFACE_API_KEY=sk-huggingface-api********cQAA

package/CHANGELOG.md

@@ -5,6 +5,25 @@ This Changelog format is based on [Keep a Changelog]
 adheres to [Semantic Versioning](https://semver.org/spec/
 v2.0.0.html).
 
+## [3.7.1] - 2025-03-27
+
+### Fixed
+- Enhanced error reporting for unsupported transport types with proper JSON stringification
+
+## [3.7.0] - 2025-03-25
+
+### Added
+- New TypeScript type exports in src/index.ts for better type accessibility
+- Enhanced type definitions for metrics and cost tracking interfaces
+- Improved type documentation for core configuration interfaces
+- Support for Model Context Protocol (MCP)
+- Added `addAllAgents` method to add all agents to the crew
+- Support for streaming responses from agents
+
+### Changed
+- Reorganized type exports in src/index.ts for better code organization
+- Updated TypeScript interfaces for better type inference and documentation
+
 ## [3.6.1] - 2025-03-22
 
 ### Changed

package/README.md

@@ -8,6 +8,8 @@ This repo simplifies development of [AxLLM](https://axllm.dev) AI Agents by usin
 - **Crew Configuration**: Define a crew of agents in a JSON file. (see [agentConfig.json](agentConfig.json) as an example)
 - **State Management**: Share state across agents in a crew, as well as with functions used by those agents.
 - **Task Execution**: Plan and execute tasks using agents in the crew.
+- **Streaming Support**: Stream agent responses in real-time for better user experience and faster feedback.
+- **Model Context Protocol (MCP)**: Support for MCP to allow agents to use MCP servers.
 
 ## Getting Started
 
@@ -240,26 +242,91 @@ const crew = new AxCrew(configFilePath, myFunctions);
 ```
 
 ### Adding Agents to the Crew
-You can add a sub-set of available agents from the config file to the crew by passing their names as an array to the `addAgentsToCrew` method.
+There are three ways to add agents to your crew, each offering different levels of control:
 
-Ensure that:
-  - agents are defined in the configuration file before adding them to the crew. 
-  - agents added in the right order (an error will be thrown if an agent is added before its dependent agents).
+#### Method 1: Add All Agents Automatically
+This is the simplest method that automatically handles all dependencies:
 
-For example, the `Manager` agent in the configuration file depends on the `Planner` and `Calculator` agents. So the `Planner` and `Calculator` agents must be added to the crew before the `Manager` agent can be added.
+```javascript
+// Initialize all agents defined in the config
+await crew.addAllAgents();
+
+// Get agent instances
+const planner = crew.agents?.get("Planner");
+const manager = crew.agents?.get("Manager");
+```
+
+This method:
+- Reads all agents from your configuration
+- Automatically determines the correct initialization order based on dependencies
+- Initializes all agents in the proper sequence
+- Throws an error if there are circular dependencies
 
-Agents can be configured with any functions from the `FunctionRegistry` available to the crew.
+#### Method 2: Add Multiple Agents with Dependencies
+This method allows you to initialize a subset of agents while still handling dependencies automatically:
 
 ```javascript
-// Add agents by providing their names
-const agentNames = ['Planner', 'Calculator', 'Manager'];
-const agents = crew.addAgentsToCrew(agentNames);
+// Add multiple agents - dependencies will be handled automatically
+await crew.addAgentsToCrew(['Manager', 'Planner', 'Calculator']);
 
-// Get agent instances
-const Planner = agents.get("Planner");
-const Manager = agents.get("Manager");
+// Or add them in multiple steps - order doesn't matter as dependencies are handled
+await crew.addAgentsToCrew(['Calculator']); // Will be initialized first
+await crew.addAgentsToCrew(['Manager']);    // Will initialize Planner first if it's a dependency
 ```
 
+This method:
+- Takes an array of agent names you want to initialize
+- Automatically handles dependencies even if not explicitly included
+- Initializes agents in the correct order regardless of the order specified
+- Throws an error if required dependencies are missing or if there are circular dependencies
+
+#### Method 3: Add Individual Agents
+This method gives you the most control but requires manual dependency management:
+
+```javascript
+// Add agents one by one - you must handle dependencies manually
+await crew.addAgent('Calculator'); // Add base agent first
+await crew.addAgent('Planner');    // Then its dependent
+await crew.addAgent('Manager');    // Then agents that depend on both
+```
+
+This method:
+- Gives you full control over the initialization process
+- Requires you to handle dependencies manually
+- Throws an error if you try to initialize an agent before its dependencies
+
+#### Dependency Handling
+The crew system automatically handles agent dependencies in the following ways:
+
+1. **Explicit Dependencies**: Defined in the agent config using the `agents` field:
+```javascript
+{
+  name: "Manager",
+  // ... other config ...
+  agents: ["Planner", "Calculator"] // Manager depends on these agents
+}
+```
+
+2. **Initialization Order**: 
+   - Base agents (no dependencies) are initialized first
+   - Dependent agents are initialized only after their dependencies
+   - Circular dependencies are detected and reported
+
+3. **Error Handling**:
+   - Missing dependencies are reported with clear error messages
+   - Circular dependencies are detected and reported
+   - Invalid agent names or configurations are caught early
+
+4. **State Management**:
+   - All initialized agents within a crew share the same state
+   - Dependencies can access and modify shared state
+   - State persists across all initialization methods
+
+Choose the method that best fits your needs:
+- Use `addAllAgents()` for simple cases where you want all agents
+- Use `addAgentsToCrew()` when you need a subset of agents with automatic dependency handling
+- Use `addAgent()` when you need fine-grained control over the initialization process
+
 ### State Management
 
 The `StatefulAxAgent` class in `src/agents/index.js` allows for shared state functionality across agents. Sub-agents can be added to an agent to create complex behaviors. All agents in the crew have access to the shared state. State can also be shared with functions that are passed to the agents. To do this, pass the `state` object as an argument to the function class as shown here https://axllm.dev/guides/functions-1/
@@ -314,6 +381,49 @@ console.log(`\n\nPlan: ${plan}`);
 console.log(`\n\nAnswer: ${answer}`);
 ```
 
+### Streaming Responses
+
+The package supports streaming responses from agents, allowing you to receive and process agent outputs in real-time. This is particularly useful for long-running tasks or when you want to provide immediate feedback to users.
+
+```javascript
+import { AxCrew, AxCrewFunctions } from '@amitdeshmukh/ax-crew';
+
+// Create and initialize crew as shown above
+const crew = new AxCrew('./agentConfig.json', AxCrewFunctions);
+await crew.addAgentsToCrew(['Planner']);
+
+const planner = crew.agents.get("Planner");
+
+// Stream responses using the forward method
+await planner.forward(
+  { task: "Create a detailed plan for a website" },
+  {
+    onStream: (chunk) => {
+      // Process each chunk of the response as it arrives
+      console.log('Received chunk:', chunk);
+    }
+  }
+);
+
+// You can also use streaming with sub-agents
+await planner.forward(
+  ai,
+  { task: "Create a detailed plan for a website" },
+  {
+    onStream: (chunk) => {
+      process.stdout.write(chunk);
+    }
+  }
+);
+```
+
+Key streaming features:
+- Real-time response processing
+- Support for both direct and sub-agent usage
+- Customizable stream handling through callbacks
+- Compatible with all agent types and configurations
+- Maintains cost tracking and state management functionality
+
 ### Tracking Usage Costs
 
 The package provides precise cost tracking capabilities for monitoring API usage across individual agents and the entire crew. Costs are calculated using high-precision decimal arithmetic to ensure accuracy.

package/dist/agents/agentConfig.d.ts

@@ -1,67 +1,37 @@
-import type { AxModelConfig, AxFunction, AxSignature } from '@ax-llm/ax';
-import { FunctionRegistryType } from '../functions/index.js';
+import type { AxFunction } from '@ax-llm/ax';
+import type { AgentConfig, CrewConfigInput, FunctionRegistryType, MCPTransportConfig, MCPStdioTransportConfig, MCPHTTPTransportConfig } from '../types.js';
 declare const AIConstructors: Record<string, any>;
 export type Provider = keyof typeof AIConstructors;
+export declare function isStdioTransport(config: MCPTransportConfig): config is MCPStdioTransportConfig;
+export declare function isHTTPTransport(config: MCPTransportConfig): config is MCPHTTPTransportConfig;
 /**
- * The configuration for an agent.
- *
- * @property {string} name - Name of the agent.
- * @property {string} description - Description of the agent.
- * @property {string | AxSignature} signature - The signature for the agent in DSPy format.
- * @property {Provider} provider - LLM provider name.
- * @property {string} providerKeyName - The name of the provider key (read from environment variables).
- * @property {AxModelConfig & { model: string }} ai - The AI model configuration to be passed to the agent.
- * @property {boolean} debug - Whether to enable debug mode.
- * @property {string} apiURL - Set this if you are using a custom API URL e.g. ollama on localhost.
- * @property {Record<string, any>} options - Agent options. Refer to the Ax documentation for more details.
- * @property {string[]} functions - Function names to be used by the agent.
- * @property {string[]} agents - Sub-agent available to the agent.
- * @property {Record<string, any>[]} examples - DSPy examples for the agent to learn from.
- */
-export interface AgentConfig {
-    name: string;
-    description: string;
-    signature: string | AxSignature;
-    provider: Provider;
-    providerKeyName?: string;
-    ai: AxModelConfig & {
-        model: string;
-    };
-    debug?: boolean;
-    apiURL?: string;
-    options?: Record<string, any>;
-    functions?: string[];
-    agents?: string[];
-    examples?: Array<Record<string, any>>;
-}
-/**
- * The input type for the agent config. This can be a path to a JSON file or a JSON object.
+ * 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 {Object} The parsed crew config.
+ * @throws Will throw an error if reading/parsing fails.
  */
-type AgentConfigInput = string | {
+declare const parseCrewConfig: (input: CrewConfigInput) => {
     crew: AgentConfig[];
 };
 /**
- * Initializes the AI agent using the specified agent name and configuration.
- * This function parses the agent's configuration, validates the presence of the necessary API key,
- * and creates an instance of the AI agent with the appropriate settings.
+ * Parses the agent's configuration, validates the presence of the necessary API key,
+ * and creates an instance of the Agent with the appropriate settings.
  *
  * @param {string} agentName - The identifier for the AI agent to be initialized.
- * @param {AgentConfigInput} agentConfig - Either a file path to the JSON configuration or a JSON object with crew configuration.
+ * @param {CrewConfigInput} crewConfig - Either a file path to the JSON configuration or 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.
  * @throws {Error} Throws an error if the agent configuration is missing, the provider is unsupported,
  * the API key is not found, or the provider key name is not specified in the configuration.
  */
-declare const getAgentConfigParams: (agentName: string, agentConfig: AgentConfigInput, functions: FunctionRegistryType, state: Record<string, any>) => {
+declare const parseAgentConfig: (agentName: string, crewConfig: CrewConfigInput, functions: FunctionRegistryType, state: Record<string, any>) => Promise<{
     ai: any;
     name: string;
     description: string;
-    signature: string | AxSignature;
-    functions: (AxFunction | (new (state: Record<string, any>) => {
-        toFunction: () => AxFunction;
-    }) | undefined)[];
+    signature: string | import("@ax-llm/ax").AxSignature;
+    functions: AxFunction[];
     subAgentNames: string[];
     examples: Record<string, any>[];
-};
-export { getAgentConfigParams, AgentConfigInput };
+}>;
+export { parseAgentConfig, parseCrewConfig };

package/dist/agents/agentConfig.js

@@ -1,5 +1,8 @@
 import fs from 'fs';
+// Import all the providers
 import { AxAIAnthropic, AxAIOpenAI, AxAIAzureOpenAI, AxAICohere, AxAIDeepSeek, AxAIGoogleGemini, AxAIGroq, AxAIHuggingFace, AxAIMistral, AxAIOllama, AxAITogether } from '@ax-llm/ax';
+// Import the MCP client and transports
+import { AxMCPClient, AxMCPStdioTransport, AxMCPHTTPTransport } from '@ax-llm/ax';
 import { PROVIDER_API_KEYS } from '../config/index.js';
 // Define a mapping from provider names to their respective constructors
 const AIConstructors = {
@@ -15,6 +18,14 @@ const AIConstructors = {
     'openai': AxAIOpenAI,
     'together': AxAITogether
 };
+// Type guard to check if config is stdio transport
+export function isStdioTransport(config) {
+    return 'command' in config;
+}
+// Type guard to check if config is http transport
+export function isHTTPTransport(config) {
+    return 'sseUrl' in config;
+}
 /**
  * Type guard to check if a value is a constructor function for a type T.
  *
@@ -67,19 +78,55 @@ Original error: ${error.message}`;
     }
     return `Error parsing agent configuration: ${error.message}`;
 };
+const initializeMCPServers = async (agentConfigData) => {
+    const mcpServers = agentConfigData.mcpServers;
+    if (!mcpServers || Object.keys(mcpServers).length === 0) {
+        return [];
+    }
+    let initializedClients = [];
+    const functions = [];
+    try {
+        for (const [mcpServerName, mcpServerConfig] of Object.entries(mcpServers)) {
+            let transport;
+            if (isStdioTransport(mcpServerConfig)) {
+                transport = new AxMCPStdioTransport({
+                    command: mcpServerConfig.command,
+                    args: mcpServerConfig.args,
+                    env: mcpServerConfig.env
+                });
+            }
+            else if (isHTTPTransport(mcpServerConfig)) {
+                transport = new AxMCPHTTPTransport(mcpServerConfig.sseUrl);
+            }
+            else {
+                throw new Error(`Unsupported transport type: ${JSON.stringify(mcpServerConfig)}`);
+            }
+            const mcpClient = new AxMCPClient(transport, { debug: agentConfigData.debug || false });
+            await mcpClient.init();
+            initializedClients.push(mcpClient);
+            functions.push(...mcpClient.toFunction());
+        }
+        return functions;
+    }
+    catch (error) {
+        initializedClients = [];
+        console.error(`Error during MCP client setup: ${error}`);
+        throw error;
+    }
+};
 /**
- * Reads the AI parameters from either a JSON configuration file or a direct JSON object.
- * @param {AgentConfigInput} input - Either a path to the agent config json file or a JSON object with crew configuration.
- * @returns {Object} The parsed agent configs.
+ * 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 {Object} The parsed crew config.
  * @throws Will throw an error if reading/parsing fails.
  */
-const parseAgentConfig = (input) => {
+const parseCrewConfig = (input) => {
     try {
         if (typeof input === 'string') {
             // Handle file path input
             const fileContents = fs.readFileSync(input, 'utf8');
-            const parsedConfigs = JSON.parse(fileContents);
-            return parsedConfigs;
+            const parsedConfig = JSON.parse(fileContents);
+            return parsedConfig;
         }
         else {
             // Handle direct JSON object input
@@ -98,22 +145,21 @@ const parseAgentConfig = (input) => {
     }
 };
 /**
- * Initializes the AI agent using the specified agent name and configuration.
- * This function parses the agent's configuration, validates the presence of the necessary API key,
- * and creates an instance of the AI agent with the appropriate settings.
+ * Parses the agent's configuration, validates the presence of the necessary API key,
+ * and creates an instance of the Agent with the appropriate settings.
  *
  * @param {string} agentName - The identifier for the AI agent to be initialized.
- * @param {AgentConfigInput} agentConfig - Either a file path to the JSON configuration or a JSON object with crew configuration.
+ * @param {CrewConfigInput} crewConfig - Either a file path to the JSON configuration or 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.
  * @throws {Error} Throws an error if the agent configuration is missing, the provider is unsupported,
  * the API key is not found, or the provider key name is not specified in the configuration.
  */
-const getAgentConfigParams = (agentName, agentConfig, functions, state) => {
+const parseAgentConfig = async (agentName, crewConfig, functions, state) => {
     try {
         // Retrieve the parameters for the specified AI agent from config
-        const agentConfigData = parseAgentConfig(agentConfig).crew.find(agent => agent.name === agentName);
+        const agentConfigData = parseCrewConfig(crewConfig).crew.find(agent => agent.name === agentName);
         if (!agentConfigData) {
             throw new Error(`AI agent with name ${agentName} is not configured`);
         }
@@ -144,24 +190,33 @@ const getAgentConfigParams = (agentName, agentConfig, functions, state) => {
         });
         // If an apiURL is provided in the agent config, set it in the AI agent
         if (agentConfigData.apiURL) {
-            ai.setAPIURL(agentConfigData.apiURL);
-        }
-        // Prepare functions for the AI agent
-        const agentFunctions = (agentConfigData.functions || [])
-            .map(funcName => {
-            const func = functions[funcName];
-            if (!func) {
-                console.warn(`Warning: Function ${funcName} not found.`);
-                return;
+            try {
+                // Validate apiURL format
+                new URL(agentConfigData.apiURL);
+                ai.setAPIURL(agentConfigData.apiURL);
             }
-            // Use the type guard to check if the function is a class
-            if (isConstructor(func)) {
-                return new func(state).toFunction();
+            catch (error) {
+                throw new Error(`Invalid apiURL provided: ${agentConfigData.apiURL}`);
             }
-            // Else the function is a function handler, return it directly
-            return func;
-        })
-            .filter(Boolean);
+        }
+        // If an mcpServers config is provided in the agent config, convert to functions
+        const mcpFunctions = await initializeMCPServers(agentConfigData);
+        // Prepare functions for the AI agent
+        const agentFunctions = [
+            // Add custom functions
+            ...(agentConfigData.functions || [])
+                .map(funcName => {
+                const func = functions[funcName];
+                if (!func) {
+                    console.warn(`Warning: Function ${funcName} not found.`);
+                    return;
+                }
+                return func;
+            })
+                .filter((func) => func !== null),
+            // Add MCP functions to functions
+            ...mcpFunctions
+        ];
         // Return AI instance and Agent parameters
         return {
             ai,
@@ -170,7 +225,7 @@ const getAgentConfigParams = (agentName, agentConfig, functions, state) => {
             signature: agentConfigData.signature,
             functions: agentFunctions,
             subAgentNames: agentConfigData.agents || [],
-            examples: agentConfigData.examples || []
+            examples: agentConfigData.examples || [],
         };
     }
     catch (error) {
@@ -180,4 +235,4 @@ const getAgentConfigParams = (agentName, agentConfig, functions, state) => {
         throw new Error(`Error setting up AI agent: ${error}`);
     }
 };
-export { getAgentConfigParams };
+export { parseAgentConfig, parseCrewConfig };

package/dist/agents/agentUseCosts.d.ts

@@ -1,56 +1,4 @@
-import type { StateInstance } from '../state/index.js';
-/**
- * The usage metrics of the model.
- * promptTokens: number;
- * completionTokens: number;
- */
-export interface ModelUsage {
-    promptTokens: number;
-    completionTokens: number;
-}
-/**
- * The published cost for using the model.
- * promptTokenCostPer1M: number;
- * completionTokenCostPer1M: number;
- */
-export interface ModelInfo {
-    promptTokenCostPer1M: number;
-    completionTokenCostPer1M: number;
-}
-/**
- * The cost incurred for using the model.
- *
- */
-export interface UsageCost {
-    promptCost: string;
-    completionCost: string;
-    totalCost: string;
-    tokenMetrics: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-}
-/**
- * Aggregated metrics from all agent and sub-agent invocations.
- *
- */
-export interface AggregatedMetrics {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-    promptCost: string;
-    completionCost: string;
-}
-/**
- * The incurred costs from all agent and sub-agent invocations.
- *
- */
-export interface AggregatedCosts {
-    totalCost: string;
-    byAgent: Record<string, UsageCost>;
-    aggregatedMetrics: AggregatedMetrics;
-}
+import type { StateInstance, ModelUsage, ModelInfo, UsageCost, AggregatedCosts } from '../types.js';
 /**
  * Utility class to handle usage related functionality.
  *

package/dist/agents/index.d.ts

@@ -1,9 +1,7 @@
 import { AxAgent, AxAI } from "@ax-llm/ax";
-import type { AxSignature, AxAgentic, AxFunction, AxProgramForwardOptions } from "@ax-llm/ax";
-import type { AgentConfigInput } from "./agentConfig.js";
-import { FunctionRegistryType } from "../functions/index.js";
-import { StateInstance } from "../state/index.js";
-import { StateFulAxAgentUsage, UsageCost } from "./agentUseCosts.js";
+import type { AxSignature, AxAgentic, AxFunction, AxProgramForwardOptions, AxProgramStreamingForwardOptions, AxGenStreamingOut } from "@ax-llm/ax";
+import type { StateInstance, FunctionRegistryType, UsageCost, CrewConfigInput, MCPTransportConfig } from "../types.js";
+import { StateFulAxAgentUsage } from "./agentUseCosts.js";
 declare class StatefulAxAgent extends AxAgent<any, any> {
     state: StateInstance;
     axai: any;
@@ -15,9 +13,12 @@ declare class StatefulAxAgent extends AxAgent<any, any> {
         agents?: AxAgentic[] | undefined;
         functions?: (AxFunction | (() => AxFunction))[] | undefined;
         examples?: Array<Record<string, any>> | undefined;
+        mcpServers?: Record<string, MCPTransportConfig> | undefined;
     }>, state: StateInstance);
     forward(values: Record<string, any>, options?: Readonly<AxProgramForwardOptions>): Promise<Record<string, any>>;
     forward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramForwardOptions>): Promise<Record<string, any>>;
+    streamingForward(values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<any>;
+    streamingForward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<any>;
     getLastUsageCost(): UsageCost | null;
     getAccumulatedCosts(): UsageCost | null;
 }
@@ -25,30 +26,30 @@ declare class StatefulAxAgent extends AxAgent<any, any> {
  * Represents a crew of agents with shared state functionality.
  */
 declare class AxCrew {
-    private agentConfig;
+    private crewConfig;
     functionsRegistry: FunctionRegistryType;
     crewId: string;
     agents: Map<string, StatefulAxAgent> | null;
     state: StateInstance;
     /**
      * Creates an instance of AxCrew.
-     * @param {AgentConfigInput} agentConfig - Either a path to the agent config file or a JSON object with crew configuration.
+     * @param {CrewConfigInput} crewConfig - Either a path to the agent config file or a JSON object with crew configuration.
      * @param {FunctionRegistryType} [functionsRegistry={}] - The registry of functions to use in the crew.
      * @param {string} [crewId=uuidv4()] - The unique identifier for the crew.
      */
-    constructor(agentConfig: AgentConfigInput, functionsRegistry?: FunctionRegistryType, crewId?: string);
+    constructor(crewConfig: CrewConfigInput, functionsRegistry?: FunctionRegistryType, crewId?: string);
     /**
      * Factory function for creating an agent.
      * @param {string} agentName - The name of the agent to create.
      * @returns {StatefulAxAgent} The created StatefulAxAgent instance.
      * @throws Will throw an error if the agent creation fails.
      */
-    createAgent: (agentName: string) => StatefulAxAgent;
+    createAgent: (agentName: string) => Promise<StatefulAxAgent>;
     /**
      * Adds an agent to the crew by name.
      * @param {string} agentName - The name of the agent to add.
      */
-    addAgent(agentName: string): void;
+    addAgent(agentName: string): Promise<void>;
     /**
      * Sets up agents in the crew by name.
      * For an array of Agent names provided, it adds
@@ -56,7 +57,8 @@ declare class AxCrew {
      * @param {string[]} agentNames - An array of agent names to configure.
      * @returns {Map<string, StatefulAxAgent> | null} A map of agent names to their corresponding instances.
      */
-    addAgentsToCrew(agentNames: string[]): Map<string, StatefulAxAgent> | null;
+    addAgentsToCrew(agentNames: string[]): Promise<Map<string, StatefulAxAgent> | null>;
+    addAllAgents(): Promise<Map<string, StatefulAxAgent> | null>;
     /**
      * Cleans up the crew by dereferencing agents and resetting the state.
      */