@amitdeshmukh/ax-crew 8.0.3 → 8.2.0

package/dist/agents/index.js

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from "uuid";
-import { AxAgent } from "@ax-llm/ax";
+import { AxAgent, AxGen } from "@ax-llm/ax";
 import { createState } from "../state/index.js";
 import { parseCrewConfig, parseAgentConfig } from "./agentConfig.js";
 import { MetricsRegistry } from "../metrics/index.js";
@@ -8,9 +8,13 @@ class StatefulAxAgent extends AxAgent {
     state;
     axai;
     agentName;
+    agentDefinition;
+    executionMode;
+    axGenProgram;
     costTracker;
-    lastRecordedCostUSD = 0;
     debugEnabled = false;
+    static modernAxAgentRuntime = typeof AxAgent?.prototype?.getFunction === "function" &&
+        typeof AxAgent?.prototype?.setExamples !== "function";
     // ACE-related optional state
     aceConfig;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,137 +24,254 @@ class StatefulAxAgent extends AxAgent {
     isAxAIService(obj) {
         return !!obj && typeof obj.getName === 'function' && typeof obj.chat === 'function';
     }
-    isAxAIInstance(obj) {
-        return !!obj && typeof obj === 'object' && ('defaults' in obj || 'modelInfo' in obj);
-    }
     constructor(ai, options, state) {
-        const { examples, debug, ...restOptions } = options;
-        const formattedOptions = {
-            ...restOptions,
-            functions: restOptions.functions?.map((fn) => typeof fn === "function" ? fn() : fn),
-        };
-        super(formattedOptions);
+        const { examples, debug } = options;
+        const resolvedFunctions = (options.functions ?? []).map((fn) => typeof fn === "function" ? fn() : fn);
+        const resolvedAgents = (options.agents ?? []);
+        const effectiveDefinition = (options.definition ?? options.description).trim();
+        if (StatefulAxAgent.modernAxAgentRuntime) {
+            const configuredAgentOptions = (options.axAgentOptions ?? {});
+            const configuredAgentGraph = (configuredAgentOptions.agents ?? {});
+            const configuredFunctionGraph = (configuredAgentOptions.functions ?? {});
+            const configuredActorOptions = (configuredAgentOptions.actorOptions ?? {});
+            const configuredResponderOptions = (configuredAgentOptions.responderOptions ?? {});
+            const modernOptions = {
+                ...configuredAgentOptions,
+                debug: debug ?? configuredAgentOptions.debug ?? false,
+                contextFields: Array.isArray(configuredAgentOptions.contextFields)
+                    ? configuredAgentOptions.contextFields
+                    : [],
+            };
+            modernOptions.agents = {
+                ...configuredAgentGraph,
+                local: resolvedAgents,
+            };
+            modernOptions.functions = {
+                ...configuredFunctionGraph,
+                local: resolvedFunctions,
+            };
+            if (effectiveDefinition.length > 0) {
+                modernOptions.actorOptions = {
+                    ...configuredActorOptions,
+                    description: configuredActorOptions.description ?? effectiveDefinition,
+                };
+                modernOptions.responderOptions = {
+                    ...configuredResponderOptions,
+                    description: configuredResponderOptions.description ?? effectiveDefinition,
+                };
+            }
+            else {
+                modernOptions.actorOptions = configuredActorOptions;
+                modernOptions.responderOptions = configuredResponderOptions;
+            }
+            super({
+                ai,
+                agentIdentity: {
+                    name: options.name,
+                    description: options.description,
+                },
+                signature: options.signature,
+            }, modernOptions);
+        }
+        else {
+            super({
+                name: options.name,
+                description: options.description,
+                definition: options.definition,
+                signature: options.signature,
+                agents: resolvedAgents,
+                functions: resolvedFunctions,
+                debug: debug ?? false,
+            }, {});
+        }
         this.state = state;
         this.axai = ai;
         this.agentName = options.name;
+        this.agentDefinition = effectiveDefinition;
+        this.executionMode = options.executionMode ?? "axgen";
         this.debugEnabled = debug ?? false;
-        // Set examples if provided
+        this.axGenProgram = new AxGen(options.signature, {
+            description: effectiveDefinition,
+            functions: resolvedFunctions,
+        });
+        for (const agent of resolvedAgents) {
+            try {
+                const childName = agent.getFunction().name;
+                this.axGenProgram.register(agent, childName);
+            }
+            catch {
+                // Best-effort registration for optimizer/introspection support.
+            }
+        }
+        // Apply examples to compatibility layer if provided
         if (examples && examples.length > 0) {
-            super.setExamples(examples);
+            this.setExamplesCompat(examples);
         }
     }
-    // Implementation
-    async forward(first, second, third) {
-        let result;
+    /**
+     * @deprecated Use setExamplesCompat() to avoid Ax runtime version coupling.
+     */
+    setExamples(examples) {
+        this.setExamplesCompat(examples);
+    }
+    setExamplesCompat(examples) {
+        this.axGenProgram.setExamples(examples);
+        const baseSetExamples = AxAgent.prototype.setExamples;
+        if (typeof baseSetExamples === "function") {
+            baseSetExamples.call(this, examples);
+            return;
+        }
+        const internalProgram = this.program;
+        if (typeof internalProgram?.setExamples === "function") {
+            internalProgram.setExamples(examples);
+        }
+    }
+    /**
+     * @deprecated Use setDescriptionCompat() to avoid Ax runtime version coupling.
+     */
+    setDescription(description) {
+        this.setDescriptionCompat(description);
+    }
+    setDescriptionCompat(description) {
+        this.agentDefinition = description;
+        this.axGenProgram.setDescription(description);
+        const baseSetDescription = AxAgent.prototype.setDescription;
+        if (typeof baseSetDescription === "function") {
+            baseSetDescription.call(this, description);
+            return;
+        }
+        const agentRuntime = this;
+        if (typeof agentRuntime.program?.setDescription === "function") {
+            agentRuntime.program.setDescription(description);
+        }
+        agentRuntime.actorDescription = description;
+        agentRuntime.responderDescription = description;
+        if (typeof agentRuntime._buildSplitPrograms === "function") {
+            agentRuntime._buildSplitPrograms();
+        }
+    }
+    getUsage() {
+        if (this.executionMode === "axgen") {
+            return this.axGenProgram.getUsage();
+        }
+        return super.getUsage();
+    }
+    resetUsage() {
+        this.axGenProgram.resetUsage();
+        super.resetUsage();
+    }
+    resolveInvocationArgs(first, second, third) {
+        const calledWithAI = this.isAxAIService(first);
+        const ai = (calledWithAI ? first : this.axai);
+        if (!ai) {
+            throw new Error(`No AI instance is configured for agent "${this.agentName}"`);
+        }
+        const values = (calledWithAI ? second : first);
+        const options = (calledWithAI ? third : second);
+        return { ai, values, options, calledWithAI };
+    }
+    async executeForwardByMode(mode, ai, values, options) {
+        if (mode === "axgen") {
+            return this.axGenProgram.forward(ai, values, options);
+        }
+        return super.forward(ai, values, options);
+    }
+    recordUsageMetrics(labels, mode) {
+        const builtIn = mode === "axgen" ? this.axGenProgram.getUsage?.() : super.getUsage?.();
+        if (!Array.isArray(builtIn))
+            return;
+        const totals = builtIn.reduce((acc, u) => {
+            const pt = u.tokens?.promptTokens ?? u.promptTokens ?? 0;
+            const ct = u.tokens?.completionTokens ?? u.completionTokens ?? 0;
+            acc.promptTokens += typeof pt === "number" ? pt : 0;
+            acc.completionTokens += typeof ct === "number" ? ct : 0;
+            const model = u.model ||
+                this.axai?.getLastUsedChatModel?.() ||
+                this.axai?.defaults?.model;
+            if (model) {
+                acc.byModel[model] = (acc.byModel[model] || 0) + (pt + ct);
+            }
+            return acc;
+        }, { promptTokens: 0, completionTokens: 0, byModel: {} });
+        MetricsRegistry.recordTokens(labels, {
+            promptTokens: totals.promptTokens,
+            completionTokens: totals.completionTokens,
+            totalTokens: totals.promptTokens + totals.completionTokens,
+        });
+        const costTracker = this.costTracker;
+        try {
+            for (const [m, count] of Object.entries(totals.byModel)) {
+                costTracker?.trackTokens?.(count, m);
+            }
+            const totalUSD = Number(costTracker?.getCurrentCost?.() ?? 0);
+            if (!Number.isNaN(totalUSD) && totalUSD > 0) {
+                MetricsRegistry.recordEstimatedCost(labels, totalUSD);
+            }
+        }
+        catch { }
+    }
+    async runForwardInvocation(mode, first, second, third) {
+        const { ai, values, options, calledWithAI } = this.resolveInvocationArgs(first, second, third);
         const start = performance.now();
-        const crewId = this.state?.crewId || (this.state.get?.('crewId')) || 'default';
+        const crewId = this.state?.crewId || this.state.get?.("crewId") || "default";
         const labels = { crewId, agent: this.agentName };
-        const input = this.isAxAIService(first) ? second : first;
         const taskId = `task_${crewId}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         // Track execution context in crew for ACE feedback routing
         const crewInstance = this.state?.crew;
         if (crewInstance) {
-            if (this.isAxAIService(first)) {
-                // For sub-agent calls, track under parent task ID
+            if (calledWithAI) {
                 const parentTaskId = this.state?.currentTaskId;
                 if (parentTaskId) {
-                    crewInstance.trackAgentExecution(parentTaskId, this.agentName, input);
+                    crewInstance.trackAgentExecution(parentTaskId, this.agentName, values);
                 }
             }
             else {
-                // Root-level call - start new execution tracking
-                crewInstance.trackAgentExecution(taskId, this.agentName, input);
+                crewInstance.trackAgentExecution(taskId, this.agentName, values);
                 this.state.currentTaskId = taskId;
             }
         }
-        // Before forward: compose instruction with current playbook (mirrors AxACE.compile behavior)
-        // This ensures the agent uses the latest playbook context for this call
         if (this.debugEnabled) {
-            console.log(`[ACE Debug] forward() called, aceConfig=${!!this.aceConfig}`);
+            console.log(`[ACE Debug] forward() called, mode=${mode}, aceConfig=${!!this.aceConfig}`);
         }
         if (this.aceConfig) {
             await this.composeInstructionWithPlaybook();
         }
-        // Execute the forward call
-        // Note: OpenTelemetry spans are automatically created by AxAI (configured via AxCrewOptions.telemetry)
-        if (this.isAxAIService(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 metrics and costs after the call using built-in usage
+        const result = await this.executeForwardByMode(mode, ai, values, options);
         const durationMs = performance.now() - start;
         MetricsRegistry.recordRequest(labels, false, durationMs);
-        // Always record tokens from built-in usage array if present
-        const builtIn = this.getUsage?.();
-        if (Array.isArray(builtIn)) {
-            const totals = builtIn.reduce((acc, u) => {
-                const pt = u.tokens?.promptTokens ?? u.promptTokens ?? 0;
-                const ct = u.tokens?.completionTokens ?? u.completionTokens ?? 0;
-                acc.promptTokens += typeof pt === 'number' ? pt : 0;
-                acc.completionTokens += typeof ct === 'number' ? ct : 0;
-                // also aggregate per-model to feed Ax tracker
-                const model = u.model || this.axai?.getLastUsedChatModel?.() || this.axai?.defaults?.model;
-                if (model) {
-                    acc.byModel[model] = (acc.byModel[model] || 0) + (pt + ct);
-                }
-                return acc;
-            }, { promptTokens: 0, completionTokens: 0, byModel: {} });
-            MetricsRegistry.recordTokens(labels, {
-                promptTokens: totals.promptTokens,
-                completionTokens: totals.completionTokens,
-                totalTokens: totals.promptTokens + totals.completionTokens,
-            });
-            // Feed Ax's cost tracker with token totals per model; Ax owns pricing
-            const costTracker = this.costTracker;
-            try {
-                for (const [m, count] of Object.entries(totals.byModel)) {
-                    costTracker?.trackTokens?.(count, m);
-                }
-                const totalUSD = Number(costTracker?.getCurrentCost?.() ?? 0);
-                if (!Number.isNaN(totalUSD) && totalUSD > 0) {
-                    MetricsRegistry.recordEstimatedCost(labels, totalUSD);
-                }
-            }
-            catch { }
-        }
-        // Record result in crew execution history for ACE feedback routing
+        this.recordUsageMetrics(labels, mode);
         if (crewInstance) {
-            if (this.isAxAIService(first)) {
-                // For sub-agent calls, record under parent task ID
+            if (calledWithAI) {
                 const parentTaskId = this.state?.currentTaskId;
                 if (parentTaskId) {
                     crewInstance.recordAgentResult(parentTaskId, this.agentName, result);
                 }
             }
             else {
-                // Root-level result - include taskId for feedback routing
                 crewInstance.recordAgentResult(taskId, this.agentName, result);
-                // Clean up current task ID
                 delete this.state.currentTaskId;
-                // Attach taskId to result for feedback routing convenience
                 result._taskId = taskId;
             }
         }
         return result;
     }
     // Implementation
-    streamingForward(first, second, third) {
+    async forward(first, second, third) {
+        return this.runForwardInvocation(this.executionMode, first, second, third);
+    }
+    runStreamingInvocation(mode, first, second, third) {
+        const { ai, values, options } = this.resolveInvocationArgs(first, second, third);
         const start = performance.now();
-        const crewId = this.state?.crewId || (this.state.get?.('crewId')) || 'default';
+        const crewId = this.state?.crewId || this.state.get?.("crewId") || "default";
         const labels = { crewId, agent: this.agentName };
-        let streamingResult;
-        if (this.isAxAIService(first)) {
-            streamingResult = super.streamingForward(this.axai, second, third);
-        }
-        else {
-            streamingResult = super.streamingForward(this.axai, first, second);
-        }
-        // Create a new async generator that tracks costs after completion
+        const createStream = () => mode === "axgen"
+            ? this.axGenProgram.streamingForward(ai, values, options)
+            : super.streamingForward(ai, values, options);
         const wrappedGenerator = (async function* () {
+            if (this.aceConfig) {
+                await this.composeInstructionWithPlaybook();
+            }
+            const streamingResult = createStream();
             try {
                 for await (const chunk of streamingResult) {
                     yield chunk;
@@ -159,50 +280,15 @@ class StatefulAxAgent extends AxAgent {
             finally {
                 const durationMs = performance.now() - start;
                 MetricsRegistry.recordRequest(labels, true, durationMs);
-                // Record tokens from built-in usage array if present
-                const builtIn = this.getUsage?.();
-                if (Array.isArray(builtIn)) {
-                    const totals = builtIn.reduce((acc, u) => {
-                        const pt = u.tokens?.promptTokens ?? u.promptTokens ?? 0;
-                        const ct = u.tokens?.completionTokens ?? u.completionTokens ?? 0;
-                        acc.promptTokens += typeof pt === 'number' ? pt : 0;
-                        acc.completionTokens += typeof ct === 'number' ? ct : 0;
-                        const model = u.model || this.axai?.getLastUsedChatModel?.() || this.axai?.defaults?.model;
-                        if (model) {
-                            acc.byModel[model] = (acc.byModel[model] || 0) + (pt + ct);
-                        }
-                        return acc;
-                    }, { promptTokens: 0, completionTokens: 0, byModel: {} });
-                    MetricsRegistry.recordTokens(labels, {
-                        promptTokens: totals.promptTokens,
-                        completionTokens: totals.completionTokens,
-                        totalTokens: totals.promptTokens + totals.completionTokens,
-                    });
-                    const costTracker = this.costTracker;
-                    try {
-                        for (const [m, count] of Object.entries(totals.byModel)) {
-                            costTracker?.trackTokens?.(count, m);
-                        }
-                        const totalUSD = Number(costTracker?.getCurrentCost?.() ?? 0);
-                        if (!Number.isNaN(totalUSD) && totalUSD > 0) {
-                            MetricsRegistry.recordEstimatedCost(labels, totalUSD);
-                        }
-                    }
-                    catch { }
-                }
-                // Record estimated cost (USD) via attached tracker if available
-                const costTracker = this.costTracker;
-                try {
-                    const totalUSD = Number(costTracker?.getCurrentCost?.() ?? 0);
-                    if (!Number.isNaN(totalUSD) && totalUSD > 0) {
-                        MetricsRegistry.recordEstimatedCost(labels, totalUSD);
-                    }
-                }
-                catch { }
+                this.recordUsageMetrics(labels, mode);
             }
         }).bind(this)();
         return wrappedGenerator;
     }
+    // Implementation
+    streamingForward(first, second, third) {
+        return this.runStreamingInvocation(this.executionMode, first, second, third);
+    }
     // Legacy cost API removed: rely on Ax trackers for cost reporting
     getLastUsageCost() { return null; }
     // Get the accumulated costs for all runs of this agent
@@ -241,7 +327,8 @@ class StatefulAxAgent extends AxAgent {
             return;
         try {
             // Capture base instruction BEFORE any playbook injection (mirrors AxACE.extractProgramInstruction)
-            this.aceBaseInstruction = this.getSignature().getDescription() || '';
+            this.aceBaseInstruction =
+                this.agentDefinition || this.getSignature().getDescription() || '';
             const { buildACEOptimizer, loadInitialPlaybook, createEmptyPlaybook } = await import('./ace.js');
             // Build optimizer with agent's AI as student
             this.aceOptimizer = buildACEOptimizer(this.axai, ace);
@@ -482,7 +569,7 @@ class AxCrew {
         try {
             const agentConfig = await parseAgentConfig(agentName, this.crewConfig, this.functionsRegistry, this.state, this.options);
             // Destructure with type assertion
-            const { ai, name, description, signature, functions, subAgentNames, examples, tracker } = agentConfig;
+            const { ai, name, executionMode, axAgentOptions, description, signature, functions, subAgentNames, examples, tracker } = agentConfig;
             // Get subagents for the AI agent
             const subAgents = subAgentNames.map((subAgentName) => {
                 if (!this.agents?.get(subAgentName)) {
@@ -538,6 +625,8 @@ class AxCrew {
             const agentState = { ...this.state, crew: this };
             const agent = new StatefulAxAgent(ai, {
                 name,
+                executionMode,
+                axAgentOptions,
                 description,
                 definition: agentConfig.definition,
                 signature,

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AxCrew } from './agents/index.js';
 import { AxCrewFunctions } from './functions/index.js';
-import type { AxCrewConfig, AxCrewOptions, AgentConfig } from './types.js';
+import type { AxCrewConfig, AxCrewOptions, AgentConfig, AgentExecutionMode, AxCrewAxAgentOptions } from './types.js';
 import type { UsageCost, AggregatedMetrics, AggregatedCosts, StateInstance, FunctionRegistryType, ACEConfig, ACETeacherConfig, ACEPersistenceConfig, ACEOptionsConfig, ACEMetricConfig } from './types.js';
 /**
  * Metrics types and helpers for request counts, token usage, and estimated cost.
@@ -29,4 +29,4 @@ export {
 /** See class JSDoc on the `AxCrew` implementation. */
 _AxCrew as AxCrew, 
 /** Built-in function registry; see file docs in `src/functions/index.ts`. */
-_AxCrewFunctions as AxCrewFunctions, FunctionRegistryType, type AggregatedMetrics, type AggregatedCosts, type AgentConfig, type AxCrewConfig, type AxCrewOptions, type StateInstance, type UsageCost, type ACEConfig, type ACETeacherConfig, type ACEPersistenceConfig, type ACEOptionsConfig, type ACEMetricConfig, };
+_AxCrewFunctions as AxCrewFunctions, FunctionRegistryType, type AggregatedMetrics, type AggregatedCosts, type AgentConfig, type AgentExecutionMode, type AxCrewAxAgentOptions, type AxCrewConfig, type AxCrewOptions, type StateInstance, type UsageCost, type ACEConfig, type ACETeacherConfig, type ACEPersistenceConfig, type ACEOptionsConfig, type ACEMetricConfig, };

package/dist/types.d.ts

@@ -1,5 +1,12 @@
-import type { AxFunction, AxSignature, AxModelConfig, AxMCPStreamableHTTPTransportOptions, AxProgramForwardOptions, AxAIArgs } from '@ax-llm/ax';
+import type { AxFunction, AxSignature, AxModelConfig, AxMCPStreamableHTTPTransportOptions, AxProgramForwardOptions, AxAIArgs, AxAgentOptions } from '@ax-llm/ax';
 export type Provider = AxAIArgs<any>['name'];
+export type AgentExecutionMode = 'axagent' | 'axgen';
+export type AxCrewAxAgentOptions = Partial<Omit<AxAgentOptions, 'agents' | 'functions' | 'contextFields'>> & {
+    contextFields?: AxAgentOptions['contextFields'];
+    agents?: AxAgentOptions['agents'];
+    functions?: AxAgentOptions['functions'];
+    fields?: AxAgentOptions['fields'];
+};
 /**
  * A state instance that is shared between agents.
  * This can be used to store data that becomes available to all agents and functions in an out-of-band manner.
@@ -181,6 +188,17 @@ interface ACEConfig {
 interface AgentConfig {
     name: string;
     description: string;
+    /**
+     * Choose the execution engine for this agent.
+     * - `axagent` (default): Uses AxAgent capabilities.
+     * - `axgen`: Uses AxGen capabilities.
+     */
+    executionMode?: AgentExecutionMode;
+    /**
+     * AxAgent runtime options (RLM mode, context fields, recursion, actor/responder options, etc).
+     * Only applies when executionMode is `axagent`.
+     */
+    axAgentOptions?: AxCrewAxAgentOptions;
     /**
      * Optional detailed persona/program definition. If provided, becomes the system prompt.
      * Must be at least 100 characters per Ax semantics.

package/examples/graphjin-database-agent.ts

@@ -86,13 +86,6 @@ Keep your responses clear and well-formatted.`,
 // Create a new instance of AxCrew with the config
 const crew = new AxCrew(config as AxCrewConfig);
 
-// Add the agents to the crew
-await crew.addAllAgents();
-
-// Get agent instances
-const managerAgent = crew.agents?.get("ManagerAgent");
-const databaseAgent = crew.agents?.get("DatabaseAgent");
-
 // Example queries to try:
 const queries = [
   "What tables are available in the database?",
@@ -109,11 +102,21 @@ console.log(`\n\nQuestion: ${userQuery}`);
 
 const main = async (): Promise<void> => {
   try {
-    const managerResponse = await managerAgent?.forward({
+    // Initialize agents inside main so initialization failures are handled here.
+    await crew.addAllAgents();
+
+    const managerAgent = crew.agents?.get("ManagerAgent");
+    const databaseAgent = crew.agents?.get("DatabaseAgent");
+
+    if (!managerAgent) {
+      throw new Error("Failed to initialize ManagerAgent");
+    }
+
+    const managerResponse = await managerAgent.forward({
       question: userQuery,
     });
 
-    console.log(`\nAnswer: ${JSON.stringify(managerResponse?.dbResult || managerResponse?.answer, null, 2)}`);
+    console.log(`\nAnswer: ${JSON.stringify(managerResponse?.answer, null, 2)}`);
 
     // Print metrics
     console.log("\nMetrics:\n+++++++++++++++++++++++++++++++++");
@@ -127,6 +130,9 @@ const main = async (): Promise<void> => {
     console.error("2. Check that GraphJin is accessible at http://localhost:8080");
     console.error("3. Verify graphjin is installed: which graphjin");
     console.error("4. Note: There's a known schema validation issue - see comments in the code");
+    throw error;
+  } finally {
+    crew.destroy();
   }
 };
 

package/examples/rlm-long-task.ts

@@ -0,0 +1,126 @@
+import dotenv from "dotenv";
+import { AxJSRuntime, AxJSRuntimePermission } from "@ax-llm/ax";
+import { AxCrew } from "../dist/index.js";
+import type { AxCrewConfig } from "../dist/index.js";
+
+dotenv.config();
+
+const runtime = new AxJSRuntime({
+  permissions: [AxJSRuntimePermission.TIMING],
+});
+
+const config: AxCrewConfig = {
+  crew: [
+    {
+      name: "Analyzer",
+      description:
+        "Analyzes a large dataset with semantic context management.",
+      executionMode: "axagent",
+      signature:
+        'context:string, query:string -> answer:string, keyFindings:string[] "Analyzes context and returns findings"',
+      provider: "google-gemini",
+      providerKeyName: "GEMINI_API_KEY",
+      ai: {
+        model: "gemini-2.5-flash",
+        temperature: 0,
+      },
+      options: {
+        debug: true,
+      },
+      axAgentOptions: {
+        // Mandatory for AxAgent RLM mode
+        contextFields: ["context"],
+        runtime,
+        maxTurns: 20,
+        maxSubAgentCalls: 40,
+        mode: "simple",
+        contextManagement: {
+          errorPruning: true,
+          hindsightEvaluation: true,
+          pruneRank: 2,
+          tombstoning: {
+            model: "gemini-2.5-flash",
+            modelConfig: { maxTokens: 60 },
+          },
+          stateInspection: { contextThreshold: 3000 },
+        },
+      },
+    },
+  ],
+};
+
+const salesData = `
+Region,Month,Product,Units,Revenue,ReturnRate
+North,Jan,Widget-A,1200,48000,0.02
+North,Jan,Widget-B,800,32000,0.05
+North,Feb,Widget-A,1350,54000,0.018
+North,Feb,Widget-B,720,28800,0.06
+North,Mar,Widget-A,900,36000,0.03
+North,Mar,Widget-B,1100,44000,0.04
+South,Jan,Widget-A,980,39200,0.025
+South,Jan,Widget-B,1500,60000,0.03
+South,Feb,Widget-A,1100,44000,0.02
+South,Feb,Widget-B,1300,52000,0.035
+South,Mar,Widget-A,760,30400,0.045
+South,Mar,Widget-B,1450,58000,0.025
+East,Jan,Widget-A,2100,84000,0.015
+East,Jan,Widget-B,600,24000,0.07
+East,Feb,Widget-A,1950,78000,0.018
+East,Feb,Widget-B,650,26000,0.065
+East,Mar,Widget-A,2300,92000,0.012
+East,Mar,Widget-B,700,28000,0.06
+West,Jan,Widget-A,1700,68000,0.022
+West,Jan,Widget-B,900,36000,0.04
+West,Feb,Widget-A,1600,64000,0.025
+West,Feb,Widget-B,950,38000,0.038
+West,Mar,Widget-A,1800,72000,0.02
+West,Mar,Widget-B,1000,40000,0.035
+`.trim();
+
+const main = async (): Promise<void> => {
+  const crew = new AxCrew(config);
+  try {
+    await crew.addAllAgents();
+
+    const analyzer = crew.agents?.get("Analyzer");
+    if (!analyzer) throw new Error("Failed to initialize Analyzer");
+
+    const result = await analyzer.forward({
+      context: salesData,
+      query:
+        "Which region and product combination has the highest revenue growth from Jan to Mar? " +
+        "Also flag combinations where return rate worsens month-over-month.",
+    });
+
+    console.log("\n=== Answer ===");
+    console.log(result.answer);
+    console.log("\n=== Key Findings ===");
+    for (const finding of result.keyFindings ?? []) {
+      console.log(" -", finding);
+    }
+
+    const agentMetrics = (analyzer as any).getMetrics?.();
+    const crewMetrics = crew.getCrewMetrics();
+
+    console.log("\n=== Cost & Usage (Agent) ===");
+    console.log(`Estimated USD: ${agentMetrics?.estimatedCostUSD ?? 0}`);
+    console.log(
+      `Tokens: prompt=${agentMetrics?.tokens?.promptTokens ?? 0}, completion=${agentMetrics?.tokens?.completionTokens ?? 0}, total=${agentMetrics?.tokens?.totalTokens ?? 0}`
+    );
+
+    console.log("\n=== Cost & Usage (Crew) ===");
+    console.log(`Estimated USD: ${crewMetrics?.estimatedCostUSD ?? 0}`);
+    console.log(
+      `Tokens: prompt=${crewMetrics?.tokens?.promptTokens ?? 0}, completion=${crewMetrics?.tokens?.completionTokens ?? 0}, total=${crewMetrics?.tokens?.totalTokens ?? 0}`
+    );
+  } finally {
+    crew.destroy();
+  }
+};
+
+main()
+  .then(() => process.exit(0))
+  .catch((error: unknown) => {
+    console.error(error);
+    process.exit(1);
+  });