@amitdeshmukh/ax-crew 3.11.3 → 4.0.1

package/src/agents/index.ts

@@ -20,7 +20,7 @@ import type {
 
 import { createState }   from "../state/index.js";
 import { parseCrewConfig, parseAgentConfig } from "./agentConfig.js";
-import { StateFulAxAgentUsage } from "./agentUseCosts.js";
+import { MetricsRegistry } from "../metrics/index.js";
 
 // Define the interface for the agent configuration
 interface ParsedAgentConfig {
@@ -36,6 +36,7 @@ interface ParsedAgentConfig {
   mcpServers?: Record<string, MCPTransportConfig>;
   subAgentNames: string[];
   examples?: Array<Record<string, any>>;
+  tracker?: any;
 }
 
 // Extend the AxAgent class from ax-llm
@@ -43,6 +44,14 @@ class StatefulAxAgent extends AxAgent<any, any> {
   state: StateInstance;
   axai: any;
   private agentName: string;
+  private costTracker?: any;
+  private lastRecordedCostUSD: number = 0;
+  private isAxAIService(obj: any): obj is AxAI {
+    return !!obj && typeof obj.getName === 'function' && typeof obj.chat === 'function';
+  }
+  private isAxAIInstance(obj: any): obj is AxAI {
+    return !!obj && typeof obj === 'object' && ('defaults' in obj || 'modelInfo' in obj);
+  }
 
   constructor(
     ai: AxAI,
@@ -76,52 +85,92 @@ class StatefulAxAgent extends AxAgent<any, any> {
   }
 
   // Function overloads for forward method
-  async forward(values: Record<string, any>, options?: Readonly<AxProgramForwardOptions>): Promise<Record<string, any>>;
-  async forward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramForwardOptions>): Promise<Record<string, any>>;
+  async forward(values: Record<string, any>, options?: Readonly<AxProgramForwardOptions<any>>): Promise<Record<string, any>>;
+  async forward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramForwardOptions<any>>): Promise<Record<string, any>>;
   
   // Implementation
   async forward(
     first: Record<string, any> | AxAI,
-    second?: Record<string, any> | Readonly<AxProgramForwardOptions>,
-    third?: Readonly<AxProgramForwardOptions>
+    second?: Record<string, any> | Readonly<AxProgramForwardOptions<any>>,
+    third?: Readonly<AxProgramForwardOptions<any>>
   ): Promise<Record<string, any>> {
     let result;
     
+    const start = performance.now();
+    const crewId = (this.state as any)?.crewId || (this.state.get?.('crewId')) || 'default';
+    const labels = { crewId, agent: this.agentName } as any;
+
     // 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) {
+    if (this.isAxAIService(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>);
+      result = await super.forward(this.axai, first, second as Readonly<AxProgramForwardOptions<any>>);
     }
 
-    // Track costs after the call
-    const cost = this.getLastUsageCost();
-    if (cost) {
-      StateFulAxAgentUsage.trackCostInState(this.agentName, cost, this.state);
+    // Track metrics and costs after the call using built-in usage
+    const durationMs = performance.now() - start;
+    MetricsRegistry.recordRequest(labels, false, durationMs);
+    // Always record tokens from built-in usage array if present
+    const builtIn = (this as any).getUsage?.();
+    if (Array.isArray(builtIn)) {
+      const totals = builtIn.reduce(
+        (acc: any, u: any) => {
+          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 as any)?.getLastUsedChatModel?.() || (this.axai as any)?.defaults?.model;
+          if (model) {
+            acc.byModel[model] = (acc.byModel[model] || 0) + (pt + ct);
+          }
+          return acc;
+        },
+        { promptTokens: 0, completionTokens: 0, byModel: {} as Record<string, number> }
+      );
+      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 as any).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 {}
     }
 
     return result;
   }
 
   // Add streaming forward method overloads
-  streamingForward(values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<any>;
-  streamingForward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<any>;
+  streamingForward(values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions<any>>): AxGenStreamingOut<any>;
+  streamingForward(ai: AxAI, values: Record<string, any>, options?: Readonly<AxProgramStreamingForwardOptions<any>>): AxGenStreamingOut<any>;
   
   // Implementation
   streamingForward(
     first: Record<string, any> | AxAI,
-    second?: Record<string, any> | Readonly<AxProgramStreamingForwardOptions>,
-    third?: Readonly<AxProgramStreamingForwardOptions>
+    second?: Record<string, any> | Readonly<AxProgramStreamingForwardOptions<any>>,
+    third?: Readonly<AxProgramStreamingForwardOptions<any>>
   ): AxGenStreamingOut<any> {
+    const start = performance.now();
+    const crewId = (this.state as any)?.crewId || (this.state.get?.('crewId')) || 'default';
+    const labels = { crewId, agent: this.agentName } as any;
     let streamingResult: AxGenStreamingOut<any>;
     
-    if ('apiURL' in first) {
+    if (this.isAxAIService(first)) {
       streamingResult = super.streamingForward(this.axai, second as Record<string, any>, third);
     } else {
-      streamingResult = super.streamingForward(this.axai, first, second as Readonly<AxProgramStreamingForwardOptions>);
+      streamingResult = super.streamingForward(this.axai, first, second as Readonly<AxProgramStreamingForwardOptions<any>>);
     }
 
     // Create a new async generator that tracks costs after completion
@@ -131,43 +180,71 @@ class StatefulAxAgent extends AxAgent<any, any> {
           yield chunk;
         }
       } finally {
-        const cost = this.getLastUsageCost();
-        if (cost) {
-          StateFulAxAgentUsage.trackCostInState(this.agentName, cost, this.state);
+        const durationMs = performance.now() - start;
+        MetricsRegistry.recordRequest(labels, true, durationMs);
+        // Record tokens from built-in usage array if present
+        const builtIn = (this as any).getUsage?.();
+        if (Array.isArray(builtIn)) {
+          const totals = builtIn.reduce(
+            (acc: any, u: any) => {
+              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 as any)?.getLastUsedChatModel?.() || (this.axai as any)?.defaults?.model;
+              if (model) {
+                acc.byModel[model] = (acc.byModel[model] || 0) + (pt + ct);
+              }
+              return acc;
+            },
+            { promptTokens: 0, completionTokens: 0, byModel: {} as Record<string, number> }
+          );
+          MetricsRegistry.recordTokens(labels, {
+            promptTokens: totals.promptTokens,
+            completionTokens: totals.completionTokens,
+            totalTokens: totals.promptTokens + totals.completionTokens,
+          });
+          const costTracker = (this as any).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 as any).costTracker;
+        try {
+          const totalUSD = Number(costTracker?.getCurrentCost?.() ?? 0);
+          if (!Number.isNaN(totalUSD) && totalUSD > 0) {
+            MetricsRegistry.recordEstimatedCost(labels, totalUSD);
+          }
+        } catch {}
       }
     }).bind(this)();
 
     return wrappedGenerator as AxGenStreamingOut<any>;
   }
 
-  // Get the usage cost for the most recent run of the agent
-  getLastUsageCost(): UsageCost | null {
-    const { modelUsage, modelInfo, defaults } = this.axai;
-    
-    // Check if all required properties exist
-    if (!modelUsage?.promptTokens || !modelUsage?.completionTokens) {
-      return null;
-    }
+  // Legacy cost API removed: rely on Ax trackers for cost reporting
+  getLastUsageCost(): UsageCost | null { return null; }
 
-    if (!modelInfo || !defaults?.model) {
-      return null;
-    }
-
-    const currentModelInfo = modelInfo.find((m: { name: string }) => m.name === defaults.model);
-    
-    if (!currentModelInfo?.promptTokenCostPer1M || !currentModelInfo?.completionTokenCostPer1M) {
-      return null;
-    }
+  // Get the accumulated costs for all runs of this agent
+  getAccumulatedCosts(): UsageCost | null { return null; }
 
-    return StateFulAxAgentUsage.calculateCost(modelUsage, currentModelInfo);
+  // Metrics API for this agent
+  getMetrics() {
+    const crewId = (this.state as any)?.crewId || (this.state.get?.('crewId')) || 'default';
+    return MetricsRegistry.snapshot({ crewId, agent: this.agentName } as any);
   }
-
-  // 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;
+  resetMetrics(): void {
+    const crewId = (this.state as any)?.crewId || (this.state.get?.('crewId')) || 'default';
+    MetricsRegistry.reset({ crewId, agent: this.agentName } as any);
   }
+
 }
 
 /**
@@ -208,6 +285,8 @@ class AxCrew {
     this.crewId = crewId;
     this.agents = new Map<string, StatefulAxAgent>();
     this.state = createState(crewId);
+    // Make crewId discoverable to metrics
+    this.state.set('crewId', crewId);
   }
 
   /**
@@ -226,7 +305,7 @@ class AxCrew {
       );
 
       // Destructure with type assertion
-      const { ai, name, description, signature, functions, subAgentNames, examples } = agentConfig;
+      const { ai, name, description, signature, functions, subAgentNames, examples, tracker } = agentConfig;
 
       // Get subagents for the AI agent
       const subAgents = subAgentNames.map((subAgentName: string) => {
@@ -238,6 +317,30 @@ class AxCrew {
         return this.agents?.get(subAgentName);
       });
 
+      // Dedupe sub-agents by name (defensive)
+      const subAgentSet = new Map<string, StatefulAxAgent>();
+      for (const sa of subAgents.filter((agent): agent is StatefulAxAgent => agent !== undefined)) {
+        const n = (sa as any)?.agentName ?? (sa as any)?.name ?? '';
+        if (!subAgentSet.has(n)) subAgentSet.set(n, sa);
+      }
+      const uniqueSubAgents = Array.from(subAgentSet.values());
+
+      // Dedupe functions by name and avoid collision with sub-agent names
+      const subAgentNameSet = new Set(uniqueSubAgents.map((sa: any) => sa?.agentName ?? sa?.name).filter(Boolean));
+      const uniqueFunctions: AxFunction[] = [];
+      const seenFn = new Set<string>();
+      for (const fn of functions.filter((fn): fn is AxFunction => fn !== undefined)) {
+        const fnName = fn.name;
+        if (subAgentNameSet.has(fnName)) {
+          // Skip function that collides with a sub-agent name
+          continue;
+        }
+        if (!seenFn.has(fnName)) {
+          seenFn.add(fnName);
+          uniqueFunctions.push(fn);
+        }
+      }
+
       // Create an instance of StatefulAxAgent
       const agent = new StatefulAxAgent(
         ai,
@@ -245,16 +348,13 @@ class AxCrew {
           name,
           description,
           signature,
-          functions: functions.filter(
-            (fn): fn is AxFunction => fn !== undefined
-          ),
-          agents: subAgents.filter(
-            (agent): agent is StatefulAxAgent => agent !== undefined
-          ),
+          functions: uniqueFunctions,
+          agents: uniqueSubAgents,
           examples,
         },
         this.state
       );
+      (agent as any).costTracker = tracker;
 
       return agent;
     } catch (error) {
@@ -394,20 +494,29 @@ class AxCrew {
     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);
+    // Reset AxAgent built-in usage and our metrics registry
+    if (this.agents) {
+      for (const [, agent] of this.agents) {
+        try { (agent as any).resetUsage?.(); } catch {}
+        try { (agent as any).resetMetrics?.(); } catch {}
+      }
+    }
+    MetricsRegistry.reset({ crewId: this.crewId });
+  }
+
+  // Metrics API
+  getCrewMetrics() {
+    return MetricsRegistry.snapshotCrew(this.crewId);
+  }
+  resetCrewMetrics(): void {
+    MetricsRegistry.reset({ crewId: this.crewId });
   }
 }
 
-export { AxCrew };
+export { AxCrew };
+export type { StatefulAxAgent };

package/src/index.ts

@@ -9,6 +9,8 @@ import type {
   StateInstance, 
   FunctionRegistryType 
 } from './types.js';
+export * from './metrics/index.js';
+export { MetricsRegistry } from './metrics/index.js';
 
 // Main AxCrew configuration interface
 /**

package/src/metrics/index.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * as MetricsRegistry from './registry.js';
+
+

package/src/metrics/registry.ts

@@ -0,0 +1,167 @@
+import type { LabelKeys, MetricsSnapshot, TokenUsage } from './types.js';
+import Big from 'big.js';
+
+type Key = string;
+
+type Counters = {
+  requests: number;
+  errors: number;
+  streaming: number;
+  durationMsSum: number;
+  durationCount: number;
+  inputTokens: number;
+  outputTokens: number;
+  estimatedCostUSD: number;
+  functionCalls: number;
+  functionLatencyMs: number;
+};
+
+const store = new Map<Key, Counters>();
+
+function keyOf(labels: LabelKeys): Key {
+  const { crewId, agent = '', provider = '', model = '' } = labels;
+  return [crewId, agent, provider, model].join('|');
+}
+
+function getOrInit(labels: LabelKeys): Counters {
+  const k = keyOf(labels);
+  let c = store.get(k);
+  if (!c) {
+    c = {
+      requests: 0,
+      errors: 0,
+      streaming: 0,
+      durationMsSum: 0,
+      durationCount: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCostUSD: 0,
+      functionCalls: 0,
+      functionLatencyMs: 0,
+    };
+    store.set(k, c);
+  }
+  return c;
+}
+
+export function recordRequest(labels: LabelKeys, streaming: boolean, durationMs: number) {
+  const c = getOrInit(labels);
+  c.requests += 1;
+  if (streaming) c.streaming += 1;
+  c.durationMsSum += durationMs;
+  c.durationCount += 1;
+}
+
+export function recordError(labels: LabelKeys) {
+  const c = getOrInit(labels);
+  c.errors += 1;
+}
+
+export function recordTokens(labels: LabelKeys, usage: TokenUsage) {
+  const c = getOrInit(labels);
+  c.inputTokens += usage.promptTokens || 0;
+  c.outputTokens += usage.completionTokens || 0;
+}
+
+export function recordEstimatedCost(labels: LabelKeys, usd: number) {
+  const c = getOrInit(labels);
+  const current = new Big(c.estimatedCostUSD || 0);
+  const addition = new Big(usd || 0);
+  c.estimatedCostUSD = Number(current.plus(addition));
+}
+
+export function recordFunctionCall(labels: LabelKeys, latencyMs: number) {
+  const c = getOrInit(labels);
+  c.functionCalls += 1;
+  c.functionLatencyMs += latencyMs || 0;
+}
+
+export function snapshot(labels: LabelKeys): MetricsSnapshot {
+  const c = getOrInit(labels);
+  const totalTokens = c.inputTokens + c.outputTokens;
+  return {
+    provider: labels.provider,
+    model: labels.model,
+    requests: {
+      totalRequests: c.requests,
+      totalErrors: c.errors,
+      errorRate: c.requests > 0 ? c.errors / c.requests : 0,
+      totalStreamingRequests: c.streaming,
+      durationMsSum: c.durationMsSum,
+      durationCount: c.durationCount,
+    },
+    tokens: {
+      promptTokens: c.inputTokens,
+      completionTokens: c.outputTokens,
+      totalTokens,
+    },
+    estimatedCostUSD: Number(new Big(c.estimatedCostUSD || 0).round(5)),
+    functions: {
+      totalFunctionCalls: c.functionCalls,
+      totalFunctionLatencyMs: c.functionLatencyMs,
+    },
+  };
+}
+
+export function reset(labels?: LabelKeys) {
+  if (!labels) {
+    store.clear();
+    return;
+  }
+  const k = keyOf(labels);
+  store.delete(k);
+}
+
+export function snapshotCrew(crewId: string): MetricsSnapshot {
+  const empty: Counters = {
+    requests: 0,
+    errors: 0,
+    streaming: 0,
+    durationMsSum: 0,
+    durationCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    estimatedCostUSD: 0,
+    functionCalls: 0,
+    functionLatencyMs: 0,
+  };
+  const agg = Array.from(store.entries()).reduce((acc, [k, v]) => {
+    if (k.startsWith(crewId + '|')) {
+      acc.requests += v.requests;
+      acc.errors += v.errors;
+      acc.streaming += v.streaming;
+      acc.durationMsSum += v.durationMsSum;
+      acc.durationCount += v.durationCount;
+      acc.inputTokens += v.inputTokens;
+      acc.outputTokens += v.outputTokens;
+      acc.estimatedCostUSD = Number(new Big(acc.estimatedCostUSD || 0).plus(v.estimatedCostUSD || 0));
+      acc.functionCalls += v.functionCalls;
+      acc.functionLatencyMs += v.functionLatencyMs;
+    }
+    return acc;
+  }, { ...empty });
+
+  const totalTokens = agg.inputTokens + agg.outputTokens;
+  return {
+    requests: {
+      totalRequests: agg.requests,
+      totalErrors: agg.errors,
+      errorRate: agg.requests > 0 ? agg.errors / agg.requests : 0,
+      totalStreamingRequests: agg.streaming,
+      durationMsSum: agg.durationMsSum,
+      durationCount: agg.durationCount,
+    },
+    tokens: {
+      promptTokens: agg.inputTokens,
+      completionTokens: agg.outputTokens,
+      totalTokens,
+    },
+    estimatedCostUSD: Number(new Big(agg.estimatedCostUSD || 0).round(5)),
+    functions: {
+      totalFunctionCalls: agg.functionCalls,
+      totalFunctionLatencyMs: agg.functionLatencyMs,
+    },
+  } as MetricsSnapshot;
+}
+
+

package/src/metrics/types.ts

@@ -0,0 +1,48 @@
+export interface TokenUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens?: number;
+}
+
+export interface CostSnapshot {
+  usdTotal: number;
+  tokenUsage: TokenUsage;
+}
+
+export interface RequestStats {
+  totalRequests: number;
+  totalErrors: number;
+  errorRate: number;
+  totalStreamingRequests: number;
+  durationMsSum: number;
+  durationCount: number;
+}
+
+export interface FunctionStats {
+  totalFunctionCalls: number;
+  totalFunctionLatencyMs: number;
+}
+
+export interface MetricsSnapshot {
+  provider?: string;
+  model?: string;
+  requests: RequestStats;
+  tokens: TokenUsage;
+  estimatedCostUSD: number;
+  functions: FunctionStats;
+}
+
+export interface LabelKeys {
+  crewId: string;
+  agent?: string;
+  provider?: string;
+  model?: string;
+}
+
+export interface BudgetConfig {
+  maxTokens?: number;
+  maxCost?: number;
+  costPerModel?: Record<string, number>; // USD per 1K tokens override
+}
+
+

package/src/types.ts

@@ -6,7 +6,23 @@ import type {
   AxProgramForwardOptions
 } from '@ax-llm/ax';
 
-import type { Provider } from './agents/agentConfig.js';
+// Canonical provider slugs supported by ai() factory
+export type Provider =
+  // Canonical slugs per docs
+  | 'openai'
+  | 'anthropic'
+  | 'google-gemini'
+  | 'mistral'
+  | 'groq'
+  | 'cohere'
+  | 'together'
+  | 'deepseek'
+  | 'ollama'
+  | 'huggingface'
+  | 'openrouter'
+  | 'azure-openai'
+  | 'reka'
+  | 'x-grok'
 
 /**
  * A state instance that is shared between agents.
@@ -132,7 +148,7 @@ interface MCPHTTPSSETransportConfig {
  * @property {string} mcpEndpoint - The HTTP endpoint URL for the MCP server.
  * @property {AxMCPStreamableHTTPTransportOptions} options - Optional transport options.
  */
-interface MCPStreambleHTTPTransportConfig {
+interface MCPStreamableHTTPTransportConfig {
   mcpEndpoint: string
   options?: AxMCPStreamableHTTPTransportOptions
 }
@@ -142,7 +158,7 @@ interface MCPStreambleHTTPTransportConfig {
  * 
  * @property {MCPStdioTransportConfig | MCPHTTPSSETransportConfig | MCPStreambleHTTPTransportConfig} config - The config for the MCP server. Config can be either stdio, http-sse, or streamable http transport.
  */
-type MCPTransportConfig = MCPStdioTransportConfig | MCPHTTPSSETransportConfig | MCPStreambleHTTPTransportConfig
+type MCPTransportConfig = MCPStdioTransportConfig | MCPHTTPSSETransportConfig | MCPStreamableHTTPTransportConfig
 
 /**
  * The configuration for an agent.
@@ -155,7 +171,7 @@ type MCPTransportConfig = MCPStdioTransportConfig | MCPHTTPSSETransportConfig |
  * @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 {Partial<AxProgramForwardOptions>} options - Agent options including thinkingTokenBudget, showThoughts, etc. Refer to the Ax documentation for more details.
+ * @property {Partial<AxProgramForwardOptions<any>> & Record<string, any>} options - Agent options including thinkingTokenBudget, showThoughts, etc. Also allows arbitrary provider-specific keys.
  * @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.
@@ -170,7 +186,7 @@ interface AgentConfig {
   ai: AxModelConfig & { model: string };
   debug?: boolean;
   apiURL?: string;
-  options?: Partial<AxProgramForwardOptions>;
+  options?: Partial<AxProgramForwardOptions<any>> & Record<string, any>;
   functions?: string[];
   agents?: string[];
   examples?: Array<Record<string, any>>;
@@ -190,10 +206,10 @@ export {
   type FunctionRegistryType,
   type MCPStdioTransportConfig,
   type MCPHTTPSSETransportConfig,
-  type MCPStreambleHTTPTransportConfig,
+  type MCPStreamableHTTPTransportConfig,
   type MCPTransportConfig,
   type ModelUsage,
   type ModelInfo,
   type UsageCost,
   type AggregatedCosts
-};
+}