@amitdeshmukh/ax-crew 3.5.1 → 3.6.0

package/CHANGELOG.md

@@ -5,6 +5,20 @@ This Changelog format is based on [Keep a Changelog]
 adheres to [Semantic Versioning](https://semver.org/spec/
 v2.0.0.html).
 
+## [3.5.3] - 2025-02-20
+
+### Added
+- New methods for crew level cost tracking:
+  - `getAggregatedCosts()` for crew-wide metrics
+  - `resetCosts()` for resetting cost tracking
+  - Enhanced `forward()` method with automatic cost tracking
+- New TypeScript interfaces for better type safety in cost tracking
+- Improved token metrics aggregation with detailed per-agent breakdowns
+
+### Fixed
+- Improved handling of cost calculations for sub-agent calls
+- Updated [examples](./examples/) to demonstrate the new cost tracking methods
+
 ## [3.5.2] - 2025-02-03
 
 ### Added

package/README.md

@@ -16,10 +16,12 @@ Install this package:
 ```bash
 npm install @amitdeshmukh/ax-crew
 ```
-AxLLM is a peer dependency, so you will need to install it separately.
+AxLLM is a peer dependency, so you will need to install it separately. 
+
+**Note:** Currently, we support AxLLM v10.0.9. We are working on updating this package to support the latest version of AxLLM as it introduces some breaking changes.
 
 ```bash
-npm install @ax-llm/ax@latest
+npm install @ax-llm/ax@10.0.9
 ```
 
 ### TypeScript Support
@@ -323,7 +325,7 @@ The package provides precise cost tracking capabilities for monitoring API usage
 const response = await Planner.forward({ task: userQuery });
 
 // Get individual agent costs
-const agentCost = Planner.getUsageCost();
+const agentCost = Planner.getLastUsageCost();
 console.log(agentCost);
 /* Output example:
 {
@@ -338,6 +340,22 @@ console.log(agentCost);
 }
 */
 
+// Get cumulative costs for the agent
+const cumulativeCost = Planner.getAccumulatedCosts();
+console.log(cumulativeCost);
+/* Output example:
+{
+  promptCost: "0.0003637500000",
+  completionCost: "0.0006100000000",
+  totalCost: "0.0009737500000",
+  tokenMetrics: {
+    promptTokens: 291,
+    completionTokens: 122,
+    totalTokens: 413
+  }
+}
+*/
+
 // Get aggregated costs for all agents in the crew
 const crewCosts = crew.getAggregatedCosts();
 console.log(crewCosts);

package/dist/agents/agentUseCosts.d.ts

@@ -17,20 +17,22 @@ export interface UsageCost {
         totalTokens: number;
     };
 }
+export interface AggregatedMetrics {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    promptCost: string;
+    completionCost: string;
+}
+export interface AggregatedCosts {
+    totalCost: string;
+    byAgent: Record<string, UsageCost>;
+    aggregatedMetrics: AggregatedMetrics;
+}
 export declare class StateFulAxAgentUsage {
     static STATE_KEY_PREFIX: string;
     static calculateCost(modelUsage: ModelUsage, modelInfo: ModelInfo): UsageCost;
     static trackCostInState(agentName: string, cost: UsageCost, state: StateInstance): void;
-    static getAggregatedCosts(state: StateInstance): {
-        totalCost: string;
-        byAgent: Record<string, UsageCost>;
-        aggregatedMetrics: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-            promptCost: string;
-            completionCost: string;
-        };
-    };
+    static getAggregatedCosts(state: StateInstance): AggregatedCosts;
     static resetCosts(state: StateInstance): void;
 }

package/dist/agents/index.d.ts

@@ -18,9 +18,8 @@ declare class StatefulAxAgent extends AxAgent<any, any> {
     }>, 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>>;
-    getUsageCost(): UsageCost | null;
-    getAggregatedCosts(): ReturnType<typeof StateFulAxAgentUsage.getAggregatedCosts>;
-    resetCosts(): void;
+    getLastUsageCost(): UsageCost | null;
+    getAccumulatedCosts(): UsageCost | null;
 }
 /**
  * Represents a crew of agents with shared state functionality.
@@ -62,5 +61,14 @@ declare class AxCrew {
      * Cleans up the crew by dereferencing agents and resetting the state.
      */
     destroy(): void;
+    /**
+     * Gets aggregated costs for all agents in the crew
+     * @returns Aggregated cost information for all agents
+     */
+    getAggregatedCosts(): ReturnType<typeof StateFulAxAgentUsage.getAggregatedCosts>;
+    /**
+     * Resets all cost tracking for the crew
+     */
+    resetCosts(): void;
 }
 export { AxCrew };

package/dist/agents/index.js

@@ -17,43 +17,42 @@ class StatefulAxAgent extends AxAgent {
         this.agentName = options.name;
         // Set examples if provided
         if (examples && examples.length > 0) {
-            this.setExamples(examples);
+            super.setExamples(examples);
         }
     }
     // Implementation
     async forward(first, second, third) {
-        // Sub-agent case (called with AI service)
         let result;
+        // Track costs regardless of whether it's a direct or sub-agent call
+        // This ensures we capture multiple legitimate calls to the same agent
         if ('apiURL' in first) {
+            // Sub-agent case (called with AI service)
             result = await super.forward(this.axai, second, third);
         }
         else {
             // Direct call case
             result = await super.forward(this.axai, first, second);
         }
-        // Track costs in state after the call
-        const cost = this.getUsageCost();
+        // Track costs after the call
+        const cost = this.getLastUsageCost();
         if (cost) {
             StateFulAxAgentUsage.trackCostInState(this.agentName, cost, this.state);
         }
         return result;
     }
-    // Get the usage cost for a run of the agent
-    getUsageCost() {
-        const { modelUsage, modelInfo, models } = this.axai;
-        const currentModelInfo = modelInfo?.find((m) => m.name === models.model);
+    // Get the usage cost for the most recent run of the agent
+    getLastUsageCost() {
+        const { modelUsage, modelInfo, defaults } = this.axai;
+        const currentModelInfo = modelInfo?.find((m) => m.name === defaults.model);
         if (!currentModelInfo || !modelUsage) {
             return null;
         }
         return StateFulAxAgentUsage.calculateCost(modelUsage, currentModelInfo);
     }
-    // Get aggregated costs for all agents in the crew
-    getAggregatedCosts() {
-        return StateFulAxAgentUsage.getAggregatedCosts(this.state);
-    }
-    // Reset all cost tracking
-    resetCosts() {
-        StateFulAxAgentUsage.resetCosts(this.state);
+    // Get the accumulated costs for all runs of this agent
+    getAccumulatedCosts() {
+        const stateKey = `${StateFulAxAgentUsage.STATE_KEY_PREFIX}${this.agentName}`;
+        return this.state.get(stateKey);
     }
 }
 /**
@@ -147,5 +146,18 @@ class AxCrew {
         this.agents = null;
         this.state.reset();
     }
+    /**
+     * Gets aggregated costs for all agents in the crew
+     * @returns Aggregated cost information for all agents
+     */
+    getAggregatedCosts() {
+        return StateFulAxAgentUsage.getAggregatedCosts(this.state);
+    }
+    /**
+     * Resets all cost tracking for the crew
+     */
+    resetCosts() {
+        StateFulAxAgentUsage.resetCosts(this.state);
+    }
 }
 export { AxCrew };

package/examples/README.md

@@ -135,13 +135,16 @@ A basic example showing core AxCrew features:
 All examples include cost tracking. You can monitor API usage costs:
 
 ```typescript
-// After running an agent
+// Get individual agent costs
 const cost = agent.getUsageCost();
 console.log("Usage cost:", cost);
 
-// Get aggregated costs for all agents
-const totalCosts = agent.getAggregatedCosts();
+// Get aggregated costs for all agents in the crew
+const totalCosts = crew.getAggregatedCosts();
 console.log("Total costs:", totalCosts);
+
+// Reset cost tracking if needed
+crew.resetCosts();
 ```
 
 ## Best Practices

package/examples/basic-researcher-writer.ts

@@ -1,4 +1,4 @@
-;import { AxCrew } from "../dist/index.js";
+import { AxCrew } from "@amitdeshmukh/ax-crew";
 
 // Example agent configuration
 const agentConfig = {
@@ -10,18 +10,24 @@ const agentConfig = {
       provider: "anthropic",
       providerKeyName: "ANTHROPIC_API_KEY",
       ai: {
-        model: "claude-3-opus-20240229"
-      }
+        model: "claude-3-sonnet-20240229"
+      },
+      options: {
+        debug: true,
+      },
     },
     {
       name: "writer",
       description: "A writing agent that creates content",
-      signature: "topic:string, research:string -> article:string",
+      signature: "topic:string -> article:string",
       provider: "anthropic",
       providerKeyName: "ANTHROPIC_API_KEY",
       ai: {
         model: "claude-3-sonnet-20240229"
       },
+      options: {
+        debug: true,
+      },
       agents: ["researcher"] // This makes writer use researcher as a sub-agent
     }
   ]
@@ -44,30 +50,23 @@ async function main() {
   }
 
   try {
-    // Use the researcher agent
-    const { research } = await researcher.forward({
-      query: "What are the key benefits of quantum computing?"
-    });
-    
     // Use the writer agent (which will internally use the researcher)
-    const article = await writer.forward({
+    const { article } = await writer.forward({
       topic: "Quantum Computing Benefits",
-      research: research
     });
 
     // Print the article
     console.log("Article:", article);
-
-    // Get costs for individual agents
-    const researcherCost = researcher.getUsageCost();
-    console.log("Researcher cost:", researcherCost);
     
-    // Get aggregated costs for all agents (includes both direct calls and sub-agent calls)
-    const totalCosts = writer.getAggregatedCosts();
-    console.log("Total cost breakdown:", JSON.stringify(totalCosts, null, 2));
+    // Print usage costs
+    console.log("\nUsage:\n+++++++++++++++++++++++++++++++++");
+    console.log("Writer Agent:", JSON.stringify(writer.getAccumulatedCosts(), null, 2));
+    console.log("Researcher Agent Last Usage:", JSON.stringify(researcher.getLastUsageCost(), null, 2));
+    console.log("Researcher Agent Accumulated:", JSON.stringify(researcher.getAccumulatedCosts(), null, 2));
+    console.log("Total Cost:", JSON.stringify(crew.getAggregatedCosts(), null, 2));
 
     // If you want to start fresh with cost tracking
-    writer.resetCosts();
+    crew.resetCosts();
     
   } finally {
     // Clean up

package/examples/solve-math-problem.ts

@@ -1,4 +1,4 @@
-import { AxCrew } from "../dist/index.js";
+import { AxCrew } from "@amitdeshmukh/ax-crew";
 
 // Define the crew configuration
 const config = {
@@ -32,7 +32,7 @@ const config = {
         temperature: 0,
       },
       options: {
-        debug: true,
+        debug: false,
       },
       agents: ["MathAgent"]
     },
@@ -47,27 +47,26 @@ const agents = crew.addAgentsToCrew(["MathAgent", "ManagerAgent"]);
 
 // Get agent instances
 const managerAgent = agents?.get("ManagerAgent");
+const mathAgent = agents?.get("MathAgent");
 
 const userQuery: string =
   "who is considered as the father of the iphone and what is the 7th root of their year of birth (precision to minimum 5 decimal places)";
 console.log(`\n\nQuestion: ${userQuery}`);
 
 const main = async (): Promise<void> => {
-  if (managerAgent) {
-    // Try with manager agent first
+  if (managerAgent && mathAgent) {
     const managerResponse = await managerAgent.forward({
       question: userQuery,
     });
 
-    console.log(
-      `\nManager's Answer: ${JSON.stringify(managerResponse.answer, null, 2)}\n`
-    );
+    console.log(`\nAnswer: ${JSON.stringify(managerResponse.answer, null, 2)}`);
 
     // Print usage costs
-    const managerCost = managerAgent.getUsageCost();
-
-    console.log("\nUsage Costs:");
-    console.log("Manager Agent:", managerCost);
+    console.log("\nUsage:\n+++++++++++++++++++++++++++++++++");
+    console.log("Manager Agent:", JSON.stringify(managerAgent.getAccumulatedCosts(), null, 2));
+    console.log("Math Agent:", JSON.stringify(mathAgent.getLastUsageCost(), null, 2));
+    console.log("Math Agent Accumulated Costs:", JSON.stringify(mathAgent.getAccumulatedCosts(), null, 2));
+    console.log("Total Cost:", JSON.stringify(crew.getAggregatedCosts(), null, 2));
   }
 };
 

package/examples/write-post-and-publish-to-wordpress.ts

@@ -1,6 +1,8 @@
-import { AxCrew } from "../dist/index.js";
-import fetch from 'node-fetch';
-import https from 'https';
+// NOTE: For a more complete example of a crew that can research a topic, write a post and publish to WordPress, please see ./write-post-and-publish-to-wordpress.ts
+
+import { AxCrew } from "@amitdeshmukh/ax-crew";
+import type { FunctionRegistryType } from "@amitdeshmukh/ax-crew";
+import { WordPressPost } from "@ax-crew/tools-wordpress";
 
 // AxCrew configuration
 const config = {
@@ -8,7 +10,7 @@ const config = {
     {
       name: "SearchQueryGenerator",
       description: "Generates a list of google search queries to help research the topic",
-      signature: "topic:string \"The topic of the blog post\", guidance:string \"guidance from the user on what the blog post should be about\" -> googleSearchQueries:string[] \"an array of google search queries to help research the topic\"",
+      signature: "topic:string \"The topic of the blog post\", guidance:string \"guidance from the user on what the blog post should be about\" -> googleSearchQueries:string[] \"an array of upto 5 google search queries to help research the topic\"",
       provider: "anthropic",
       providerKeyName: "ANTHROPIC_API_KEY",
       ai: {
@@ -27,12 +29,15 @@ const config = {
       provider: "google-gemini",
       providerKeyName: "GEMINI_API_KEY",
       ai: {
-        model: "gemini-2.0-flash-exp",
+        model: "gemini-1.5-pro",
         temperature: 0.5
       },
       options: {
         debug: true,
-        stream: false
+        stream: false,
+        googleSearchRetrieval: {
+          mode: "MODE_UNSPECIFIED"
+        }
       }
     },
     {
@@ -49,93 +54,83 @@ const config = {
         debug: true,
         stream: false
       }
+    },
+    {
+      name: "WordPressPoster",
+      description: "Creates a post on WordPress with the given title, content and status",
+      signature: "blogPostTitle:string \"the title of the blog post\", blogPostContent:string \"the content of the blog post.\", status:string \"the status of the post (draft, publish, private)\" -> postResponse:string \"the response from the WordPress API\"",
+      provider: "anthropic",
+      providerKeyName: "ANTHROPIC_API_KEY",
+      ai: {
+        model: "claude-3-5-sonnet-20240620",
+        temperature: 0
+      },
+      options: {
+        debug: true,
+        stream: false
+      },
+      functions: ["WordPressPost"]
     }
   ]
 };
 
-// Function to post to WordPress
-async function postToWordPress(title: string, content: string, status: 'draft' | 'publish' = 'draft') {
-  const wpUrl = process.env.WORDPRESS_URL;
-  const wpUsername = process.env.WORDPRESS_USERNAME;
-  const wpPassword = process.env.WORDPRESS_PASSWORD;
-
-  if (!wpUrl) {
-    throw new Error('WordPress credentials not found in environment variables');
-  }
-
-  const auth = Buffer.from(`${wpUsername}:${wpPassword}`).toString('base64');
-  
-  const httpsAgent = new https.Agent({
-    rejectUnauthorized: false
-  });
-
-  try {
-    const response = await fetch(`${wpUrl}/wp-json/wp/v2/posts`, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Basic ${auth}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        title,
-        content,
-        status
-      }),
-      agent: httpsAgent
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`WordPress API error: ${error}`);
-    }
-
-    const post = await response.json();
-    return {
-      id: post.id,
-      url: post.link,
-      status: post.status
-    };
-  } catch (error) {
-    console.error('Error details:', error);
-    throw new Error(`Failed to post to WordPress: ${error.message}`);
-  }
-}
-
 const main = async () => {
   // Create crew with type checking
-  const crew = new AxCrew(config);
+  const customFunctions: FunctionRegistryType = {
+    WordPressPost: WordPressPost
+  };
+  const crew = new AxCrew(config, customFunctions);
+
+  // Add agents to crew
+  const agents = crew.addAgentsToCrew([
+    'SearchQueryGenerator', 
+    'GoogleSearch', 
+    'BlogPostWriter', 
+    'WordPressPoster'
+  ]);
+
+  // NOTE: Your Wordpress site needs to have the Basic Auth plugin installed and enabled for the automatic posting to work
+  // Refer to https://github.com/WP-API/Basic-Auth?tab=readme-ov-file
+  
+  // Set environment variables
+  crew.state.set("env", {
+    WORDPRESS_URL: "http://my-wordpress-site.com",
+    WORDPRESS_USERNAME: "my-username",
+    WORDPRESS_PASSWORD: "my-password"
+  });
 
-  // Type-safe agent management
-  const agents = crew.addAgentsToCrew(['SearchQueryGenerator', 'GoogleSearch', 'BlogPostWriter']);
+  // Get agents from crew
   const planner = agents?.get('SearchQueryGenerator');
   const googleSearch = agents?.get('GoogleSearch');
   const writer = agents?.get('BlogPostWriter');
+  const poster = agents?.get('WordPressPoster');
 
-  const topic = "How to tell what your cat is thinking";
-  const guidance = "The article should be a fun and engaging article that will help the reader to understand their cat better.";
+  // Define the topic and guidance
+  const topic = "How to tell what your dog is thinking";
+  const guidance = "The article should be a fun and engaging article and less that 500 words long. It should help the reader to understand their dog better.";
 
-  if (planner && googleSearch && writer) {
-    // Type-safe agent usage
+  if (planner && googleSearch && writer && poster) {
+    // Generate search queries
     const plannerResponse = await planner.forward({ topic, guidance });
     const { googleSearchQueries } = plannerResponse;
 
+    // Research the topic
     const googleSearchResults: string[] = [];
     for (const query of googleSearchQueries) {
       const googleSearchResponse = await googleSearch.forward({ googleSearchQuery: query });
       const { googleSearchResult } = googleSearchResponse;
       googleSearchResults.push(googleSearchResult);
+      // Wait for 3 seconds between queries to avoid rate limiting
+      await new Promise(resolve => setTimeout(resolve, 3000));
     }
 
-
+    // Write the blog post
     const writerResponse = await writer.forward({ topic, guidance, googleSearchResults });
     const { blogPostTitle, blogPostContent } = writerResponse;
 
-    console.log(blogPostTitle);
-    console.log(blogPostContent);
-
     // Post to WordPress
     try {
-      const postResponse = await postToWordPress(blogPostTitle, blogPostContent, 'publish');
+      const postResponse = await poster.forward({ blogPostTitle, blogPostContent, status: "publish" });
       console.log('Successfully posted to WordPress:', postResponse);
     } catch (error) {
       console.error('Failed to post to WordPress:', error);

package/index.d.ts

@@ -1,15 +1,7 @@
 import { AxAI, AxAgentic, AxFunction, AxSignature, AxProgramForwardOptions, AxModelConfig, AxAgent } from "@ax-llm/ax";
+import type { UsageCost, AggregatedCosts } from "./src/agents/agentUseCosts.js";
 
-export interface UsageCost {
-  promptCost: string;
-  completionCost: string;
-  totalCost: string;
-  tokenMetrics: {
-    promptTokens: number;
-    completionTokens: number;
-    totalTokens: number;
-  };
-}
+export { UsageCost, AggregatedCosts };
 
 export interface StateInstance {
   reset(): void;
@@ -83,6 +75,8 @@ export class AxCrew {
   createAgent(agentName: string): StatefulAxAgent;
   addAgent(agentName: string): void;
   addAgentsToCrew(agentNames: string[]): Map<string, StatefulAxAgent> | null;
+  getAggregatedCosts(): AggregatedCosts;
+  resetCosts(): void;
   destroy(): void;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@amitdeshmukh/ax-crew",
-  "version": "3.5.1",
+  "version": "3.6.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",
@@ -19,7 +19,7 @@
     "uuid": "^10.0.0"
   },
   "peerDependencies": {
-    "@ax-llm/ax": "^10.0.9"
+    "@ax-llm/ax": "^11.0.21"
   },
   "devDependencies": {
     "@types/node": "^20.14.9",

package/src/agents/agentUseCosts.ts

@@ -22,6 +22,20 @@ export interface UsageCost {
   }
 }
 
+export interface AggregatedMetrics {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+  promptCost: string;
+  completionCost: string;
+}
+
+export interface AggregatedCosts {
+  totalCost: string;
+  byAgent: Record<string, UsageCost>;
+  aggregatedMetrics: AggregatedMetrics;
+}
+
 // Utility class to handle usage related functionality
 export class StateFulAxAgentUsage {
   static STATE_KEY_PREFIX = 'agent_usage_';
@@ -78,17 +92,7 @@ export class StateFulAxAgentUsage {
     }
   }
 
-  static getAggregatedCosts(state: StateInstance): { 
-    totalCost: string;
-    byAgent: Record<string, UsageCost>;
-    aggregatedMetrics: {
-      promptTokens: number;
-      completionTokens: number;
-      totalTokens: number;
-      promptCost: string;
-      completionCost: string;
-    };
-  } {
+  static getAggregatedCosts(state: StateInstance): AggregatedCosts {
     const allState = state.getAll();
     const agentCosts: Record<string, UsageCost> = {};
     let totalPromptTokens = 0;

package/src/agents/index.ts

@@ -59,7 +59,7 @@ class StatefulAxAgent extends AxAgent<any, any> {
 
     // Set examples if provided
     if (examples && examples.length > 0) {
-      this.setExamples(examples);
+      super.setExamples(examples);
     }
   }
 
@@ -73,17 +73,20 @@ class StatefulAxAgent extends AxAgent<any, any> {
     second?: Record<string, any> | Readonly<AxProgramForwardOptions>,
     third?: Readonly<AxProgramForwardOptions>
   ): Promise<Record<string, any>> {
-    // Sub-agent case (called with AI service)
     let result;
+    
+    // Track costs regardless of whether it's a direct or sub-agent call
+    // This ensures we capture multiple legitimate calls to the same agent
     if ('apiURL' in first) {
+      // Sub-agent case (called with AI service)
       result = await super.forward(this.axai, second as Record<string, any>, third);
     } else {
       // Direct call case
       result = await super.forward(this.axai, first, second as Readonly<AxProgramForwardOptions>);
     }
 
-    // Track costs in state after the call
-    const cost = this.getUsageCost();
+    // Track costs after the call
+    const cost = this.getLastUsageCost();
     if (cost) {
       StateFulAxAgentUsage.trackCostInState(this.agentName, cost, this.state);
     }
@@ -91,10 +94,10 @@ class StatefulAxAgent extends AxAgent<any, any> {
     return result;
   }
 
-  // Get the usage cost for a run of the agent
-  getUsageCost(): UsageCost | null {
-    const { modelUsage, modelInfo, models } = this.axai;
-    const currentModelInfo = modelInfo?.find((m: { name: string }) => m.name === models.model);
+  // Get the usage cost for the most recent run of the agent
+  getLastUsageCost(): UsageCost | null {
+    const { modelUsage, modelInfo, defaults } = this.axai;
+    const currentModelInfo = modelInfo?.find((m: { name: string }) => m.name === defaults.model);
     
     if (!currentModelInfo || !modelUsage) {
       return null;
@@ -103,14 +106,10 @@ class StatefulAxAgent extends AxAgent<any, any> {
     return StateFulAxAgentUsage.calculateCost(modelUsage, currentModelInfo);
   }
 
-  // Get aggregated costs for all agents in the crew
-  getAggregatedCosts(): ReturnType<typeof StateFulAxAgentUsage.getAggregatedCosts> {
-    return StateFulAxAgentUsage.getAggregatedCosts(this.state);
-  }
-
-  // Reset all cost tracking
-  resetCosts(): void {
-    StateFulAxAgentUsage.resetCosts(this.state);
+  // Get the accumulated costs for all runs of this agent
+  getAccumulatedCosts(): UsageCost | null {
+    const stateKey = `${StateFulAxAgentUsage.STATE_KEY_PREFIX}${this.agentName}`;
+    return this.state.get(stateKey) as UsageCost | null;
   }
 }
 
@@ -235,6 +234,21 @@ class AxCrew {
     this.agents = null;
     this.state.reset();
   }
+
+  /**
+   * Gets aggregated costs for all agents in the crew
+   * @returns Aggregated cost information for all agents
+   */
+  getAggregatedCosts(): ReturnType<typeof StateFulAxAgentUsage.getAggregatedCosts> {
+    return StateFulAxAgentUsage.getAggregatedCosts(this.state);
+  }
+
+  /**
+   * Resets all cost tracking for the crew
+   */
+  resetCosts(): void {
+    StateFulAxAgentUsage.resetCosts(this.state);
+  }
 }
 
 export { AxCrew };