@ax-llm/ax 13.0.6 → 13.0.8

package/index.d.cts

@@ -285,10 +285,64 @@ type AxInternalEmbedRequest<TEmbedModel> = Omit<AxEmbedRequest, 'embedModel'> &
 type AxRateLimiterFunction = <T = unknown>(reqFunc: () => Promise<T | ReadableStream<T>>, info: Readonly<{
     modelUsage?: AxModelUsage;
 }>) => Promise<T | ReadableStream<T>>;
-type AxLoggerTag = 'error' | 'warning' | 'functionName' | 'functionArg' | 'functionResult' | 'functionError' | 'firstFunction' | 'multipleFunctions' | 'responseContent' | 'responseDelta' | 'responseEnd' | 'requestStart' | 'requestContent' | 'systemContent' | 'userStart' | 'userContent' | 'assistantStart' | 'assistantContent' | 'assistantEnd' | 'discovery' | 'optimizer' | 'start' | 'end' | 'config' | 'phase' | 'progress' | 'result' | 'complete' | 'checkpoint';
-type AxLoggerFunction = (message: string, options?: {
-    tags?: AxLoggerTag[];
-}) => void;
+type AxLoggerData = {
+    name: 'ChatRequestChatPrompt';
+    step: number;
+    value: AxChatRequest['chatPrompt'];
+} | {
+    name: 'FunctionResults';
+    value: AxFunctionResult[];
+} | {
+    name: 'ChatResponseResults';
+    value: AxChatResponseResult[];
+} | {
+    name: 'ChatResponseStreamingResult';
+    index: number;
+    value: AxChatResponseResult & {
+        delta?: string;
+    };
+} | {
+    name: 'FunctionError';
+    index: number;
+    fixingInstructions: string;
+    error: unknown;
+} | {
+    name: 'ValidationError';
+    index: number;
+    fixingInstructions: string;
+    error: unknown;
+} | {
+    name: 'AssertionError';
+    index: number;
+    fixingInstructions: string;
+    error: unknown;
+} | {
+    name: 'RefusalError';
+    index: number;
+    error: unknown;
+} | {
+    name: 'ResultPickerUsed';
+    sampleCount: number;
+    selectedIndex: number;
+    latency: number;
+} | {
+    name: 'Notification';
+    id: string;
+    value: string;
+} | {
+    name: 'EmbedRequest';
+    embedModel: string;
+    value: readonly string[];
+} | {
+    name: 'EmbedResponse';
+    totalEmbeddings: number;
+    value: {
+        length: number;
+        sample: number[];
+        truncated: boolean;
+    }[];
+};
+type AxLoggerFunction = (message: AxLoggerData) => void;
 type AxAIPromptConfig = {
     stream?: boolean;
     thinkingTokenBudget?: 'minimal' | 'low' | 'medium' | 'high' | 'highest' | 'none';
@@ -309,7 +363,7 @@ type AxAIServiceOptions = {
 type AxAIServiceActionOptions<TModel = unknown, TEmbedModel = unknown> = {
     ai?: Readonly<AxAIService<TModel, TEmbedModel>>;
     sessionId?: string;
-    traceId?: string;
+    traceId?: string | undefined;
     timeout?: number;
     rateLimiter?: AxRateLimiterFunction;
     debug?: boolean;
@@ -317,6 +371,7 @@ type AxAIServiceActionOptions<TModel = unknown, TEmbedModel = unknown> = {
     traceContext?: Context;
     abortSignal?: AbortSignal;
     logger?: AxLoggerFunction;
+    stepIndex?: number;
     functionResultFormatter?: (result: unknown) => string;
 };
 interface AxAIService<TModel = unknown, TEmbedModel = unknown> {
@@ -2686,62 +2741,10 @@ declare class AxSignature {
     };
 }
 
-type AxFieldValue = string | string[] | number | boolean | object | null | undefined | {
-    mimeType: string;
-    data: string;
-} | {
-    mimeType: string;
-    data: string;
-}[] | {
-    format?: 'wav';
-    data: string;
-} | {
-    format?: 'wav';
-    data: string;
-}[];
-type AxGenIn = {
-    [key: string]: AxFieldValue;
-};
-type AxGenOut = {
-    [key: string]: AxFieldValue;
-};
-type AxMessage<IN extends AxGenIn> = {
-    role: 'user';
-    values: IN;
-} | {
-    role: 'assistant';
-    values: IN;
-};
-
-interface AxAssertion {
-    fn(values: Record<string, unknown>): Promise<boolean | undefined> | boolean | undefined;
-    message?: string;
-}
-interface AxStreamingAssertion {
-    fieldName: string;
-    fn(content: string, done?: boolean): boolean | undefined;
-    message?: string;
-}
-declare class AxAssertionError extends Error {
-    constructor({ message, }: Readonly<{
-        message: string;
-    }>);
-    getFixingInstructions: () => {
-        name: string;
-        title: string;
-        description: string;
-    }[];
-    toString(): string;
-}
-
 declare class AxMemory implements AxAIMemory {
-    private options?;
     private memories;
     private defaultMemory;
-    constructor(options?: {
-        debug?: boolean;
-        debugHideSystemPrompt?: boolean;
-    } | undefined);
+    constructor();
     private getMemory;
     addRequest(value: AxChatRequest['chatPrompt'], sessionId?: string): void;
     addResponse(results: Readonly<AxChatResponseResult[]>, sessionId?: string): void;
@@ -2884,6 +2887,32 @@ declare class AxPromptTemplate {
     private defaultRenderInField;
 }
 
+type AxFieldValue = string | string[] | number | boolean | object | null | undefined | {
+    mimeType: string;
+    data: string;
+} | {
+    mimeType: string;
+    data: string;
+}[] | {
+    format?: 'wav';
+    data: string;
+} | {
+    format?: 'wav';
+    data: string;
+}[];
+type AxGenIn = {
+    [key: string]: AxFieldValue;
+};
+type AxGenOut = {
+    [key: string]: AxFieldValue;
+};
+type AxMessage<IN extends AxGenIn> = {
+    role: 'user';
+    values: IN;
+} | {
+    role: 'assistant';
+    values: IN;
+};
 type AxProgramTrace<IN extends AxGenIn, OUT extends AxGenOut> = {
     trace: OUT & IN;
     programId: string;
@@ -2932,7 +2961,6 @@ type AxProgramForwardOptions = {
     functionResultFormatter?: (result: unknown) => string;
     fastFail?: boolean;
     debug?: boolean;
-    debugHideSystemPrompt?: boolean;
     thinkingTokenBudget?: 'minimal' | 'low' | 'medium' | 'high' | 'highest' | 'none';
     showThoughts?: boolean;
     traceLabel?: string;
@@ -2954,6 +2982,10 @@ type AxGenDeltaOut<OUT extends AxGenOut> = {
 };
 type AxGenStreamingOut<OUT extends AxGenOut> = AsyncGenerator<AxGenDeltaOut<OUT>, void, unknown>;
 type AxSetExamplesOptions = {};
+interface AxForwardable<IN extends AxGenIn, OUT extends AxGenOut> {
+    forward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
+    streamingForward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
+}
 interface AxTunable<IN extends AxGenIn, OUT extends AxGenOut> {
     setExamples: (examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>) => void;
     setId: (id: string) => void;
@@ -2965,6 +2997,9 @@ interface AxUsable {
     getUsage: () => AxProgramUsage[];
     resetUsage: () => void;
 }
+interface AxProgrammable<IN extends AxGenIn, OUT extends AxGenOut> extends AxForwardable<IN, OUT>, AxTunable<IN, OUT>, AxUsable {
+    getSignature: () => AxSignature;
+}
 type AxProgramUsage = AxChatResponse['modelUsage'] & {
     ai: string;
     model: string;
@@ -2973,77 +3008,26 @@ interface AxProgramOptions {
     description?: string;
     traceLabel?: string;
 }
-declare class AxProgram<IN extends AxGenIn, OUT extends AxGenOut> implements AxTunable<IN, OUT>, AxUsable {
-    protected signature: AxSignature;
-    protected sigHash: string;
-    protected examples?: OUT[];
-    protected examplesOptions?: AxSetExamplesOptions;
-    protected demos?: OUT[];
-    protected trace?: OUT;
-    protected usage: AxProgramUsage[];
-    protected traceLabel?: string;
-    private key;
-    private children;
-    constructor(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: Readonly<AxProgramOptions>);
-    getSignature(): AxSignature;
-    register(prog: Readonly<AxTunable<IN, OUT> & AxUsable>): void;
-    forward(_ai: Readonly<AxAIService>, _values: IN | AxMessage<IN>[], _options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
-    streamingForward(_ai: Readonly<AxAIService>, _values: IN | AxMessage<IN>[], _options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
-    setId(id: string): void;
-    setParentId(parentId: string): void;
-    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
-    private _setExamples;
-    getTraces(): AxProgramTrace<IN, OUT>[];
-    getUsage(): AxProgramUsage[];
-    resetUsage(): void;
-    setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
-}
 
-type AxRewriteIn = {
-    query: string;
-};
-type AxRewriteOut = {
-    rewrittenQuery: string;
-};
-type AxRerankerIn = {
-    query: string;
-    items: string[];
-};
-type AxRerankerOut = {
-    rankedItems: string[];
-};
-interface AxDBLoaderOptions {
-    chunker?: (text: string) => string[];
-    rewriter?: AxProgram<AxRewriteIn, AxRewriteOut>;
-    reranker?: AxProgram<AxRerankerIn, AxRerankerOut>;
-}
-interface AxDBManagerArgs {
-    ai: AxAIService;
-    db: AxDBService;
-    config?: AxDBLoaderOptions;
+interface AxAssertion {
+    fn(values: Record<string, unknown>): Promise<boolean | undefined> | boolean | undefined;
+    message?: string;
 }
-interface AxDBMatch {
-    score: number;
-    text: string;
+interface AxStreamingAssertion {
+    fieldName: string;
+    fn(content: string, done?: boolean): boolean | undefined;
+    message?: string;
 }
-declare class AxDBManager {
-    private ai;
-    private db;
-    private chunker;
-    private rewriter?;
-    private reranker?;
-    constructor({ ai, db, config }: Readonly<AxDBManagerArgs>);
-    private defaultChunker;
-    insert: (text: Readonly<string | string[]>, options?: Readonly<{
-        batchSize?: number;
-        maxWordsPerChunk?: number;
-        minWordsPerChunk?: number;
-        abortSignal?: AbortSignal;
-    }>) => Promise<void>;
-    query: (query: Readonly<string | string[] | number | number[]>, { topPercent, abortSignal, }?: Readonly<{
-        topPercent?: number;
-        abortSignal?: AbortSignal;
-    }> | undefined) => Promise<AxDBMatch[][]>;
+declare class AxAssertionError extends Error {
+    constructor({ message, }: Readonly<{
+        message: string;
+    }>);
+    getFixingInstructions: () => {
+        name: string;
+        title: string;
+        description: string;
+    }[];
+    toString(): string;
 }
 
 type AxFieldProcessorProcess = (value: AxFieldValue, context?: Readonly<{
@@ -3067,6 +3051,33 @@ interface AxFieldProcessor {
     process: AxFieldProcessorProcess | AxStreamingFieldProcessorProcess;
 }
 
+declare class AxProgram<IN extends AxGenIn, OUT extends AxGenOut> implements AxUsable {
+    protected signature: AxSignature;
+    protected sigHash: string;
+    protected examples?: OUT[];
+    protected examplesOptions?: AxSetExamplesOptions;
+    protected demos?: OUT[];
+    protected trace?: OUT;
+    protected usage: AxProgramUsage[];
+    protected traceLabel?: string;
+    private key;
+    private children;
+    constructor(signature: ConstructorParameters<typeof AxSignature>[0], options?: Readonly<AxProgramOptions>);
+    getSignature(): AxSignature;
+    setSignature(signature: ConstructorParameters<typeof AxSignature>[0]): void;
+    setDescription(description: string): void;
+    private updateSignatureHash;
+    register(prog: Readonly<AxTunable<IN, OUT> & AxUsable>): void;
+    setId(id: string): void;
+    setParentId(parentId: string): void;
+    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
+    private _setExamples;
+    getTraces(): AxProgramTrace<IN, OUT>[];
+    getUsage(): AxProgramUsage[];
+    resetUsage(): void;
+    setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
+}
+
 type AxGenerateResult<OUT extends AxGenOut> = OUT & {
     thought?: string;
 };
@@ -3090,7 +3101,7 @@ interface AxStreamingEvent<T> {
         functions?: AxChatResponseFunctionCall[];
     };
 }
-declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxProgram<IN, OUT> {
+declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxProgram<IN, OUT> implements AxProgrammable<IN, OUT> {
     private promptTemplate;
     private asserts;
     private streamingAsserts;
@@ -3138,6 +3149,53 @@ declare class AxGenerateError extends Error {
     constructor(message: string, details: Readonly<AxGenerateErrorDetails>, options?: ErrorOptions);
 }
 
+type AxRewriteIn = {
+    query: string;
+};
+type AxRewriteOut = {
+    rewrittenQuery: string;
+};
+type AxRerankerIn = {
+    query: string;
+    items: string[];
+};
+type AxRerankerOut = {
+    rankedItems: string[];
+};
+interface AxDBLoaderOptions {
+    chunker?: (text: string) => string[];
+    rewriter?: AxGen<AxRewriteIn, AxRewriteOut>;
+    reranker?: AxGen<AxRerankerIn, AxRerankerOut>;
+}
+interface AxDBManagerArgs {
+    ai: AxAIService;
+    db: AxDBService;
+    config?: AxDBLoaderOptions;
+}
+interface AxDBMatch {
+    score: number;
+    text: string;
+}
+declare class AxDBManager {
+    private ai;
+    private db;
+    private chunker;
+    private rewriter?;
+    private reranker?;
+    constructor({ ai, db, config }: Readonly<AxDBManagerArgs>);
+    private defaultChunker;
+    insert: (text: Readonly<string | string[]>, options?: Readonly<{
+        batchSize?: number;
+        maxWordsPerChunk?: number;
+        minWordsPerChunk?: number;
+        abortSignal?: AbortSignal;
+    }>) => Promise<void>;
+    query: (query: Readonly<string | string[] | number | number[]>, { topPercent, abortSignal, }?: Readonly<{
+        topPercent?: number;
+        abortSignal?: AbortSignal;
+    }> | undefined) => Promise<AxDBMatch[][]>;
+}
+
 declare class AxDefaultResultReranker extends AxGen<AxRerankerIn, AxRerankerOut> {
     constructor(options?: Readonly<AxProgramForwardOptions>);
     forward: (ai: Readonly<AxAIService>, input: Readonly<AxRerankerIn>, options?: Readonly<AxProgramForwardOptions>) => Promise<AxRerankerOut>;
@@ -3231,8 +3289,61 @@ declare const AxEvalUtil: {
     novelF1ScoreOptimized: typeof novelF1ScoreOptimized;
 };
 
-type AxExample = Record<string, AxFieldValue>;
-type AxMetricFn = <T extends AxGenOut = AxGenOut>(arg0: Readonly<{
+type AxOptimizerLoggerData = {
+    name: 'OptimizationStart';
+    value: {
+        optimizerType: string;
+        config: Record<string, unknown>;
+        exampleCount: number;
+        validationCount: number;
+    };
+} | {
+    name: 'RoundProgress';
+    value: {
+        round: number;
+        totalRounds: number;
+        currentScore: number;
+        bestScore: number;
+        configuration: Record<string, unknown>;
+    };
+} | {
+    name: 'EarlyStopping';
+    value: {
+        reason: string;
+        finalScore: number;
+        round: number;
+    };
+} | {
+    name: 'OptimizationComplete';
+    value: {
+        bestScore: number;
+        bestConfiguration: Record<string, unknown>;
+        stats: AxOptimizationStats;
+    };
+} | {
+    name: 'ConfigurationProposal';
+    value: {
+        type: 'instructions' | 'demos' | 'general';
+        proposals: string[] | Record<string, unknown>[];
+        count: number;
+    };
+} | {
+    name: 'BootstrappedDemos';
+    value: {
+        count: number;
+        demos: unknown[];
+    };
+} | {
+    name: 'BestConfigFound';
+    value: {
+        config: Record<string, unknown>;
+        score: number;
+    };
+};
+type AxOptimizerLoggerFunction = (data: AxOptimizerLoggerData) => void;
+
+type AxExample = Record<string, AxFieldValue>;
+type AxMetricFn = <T extends AxGenOut = AxGenOut>(arg0: Readonly<{
     prediction: T;
     example: AxExample;
 }>) => number | Promise<number>;
@@ -3251,6 +3362,7 @@ interface AxOptimizationProgress {
     successfulExamples: number;
     totalExamples: number;
     currentConfiguration?: Record<string, unknown>;
+    bestConfiguration?: Record<string, unknown>;
     convergenceInfo?: {
         improvement: number;
         stagnationRounds: number;
@@ -3305,6 +3417,8 @@ type AxOptimizerArgs = {
     logger?: AxLoggerFunction;
     verbose?: boolean;
     seed?: number;
+    debugOptimizer?: boolean;
+    optimizerLogger?: AxOptimizerLoggerFunction;
 };
 interface AxOptimizationStats {
     totalCalls: number;
@@ -3316,6 +3430,8 @@ interface AxOptimizationStats {
         patienceExhausted: boolean;
         reason: string;
     };
+    bestScore: number;
+    bestConfiguration?: Record<string, unknown>;
     resourceUsage: {
         totalTokens: number;
         totalTime: number;
@@ -3422,7 +3538,7 @@ interface AxOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * @param options Optional configuration options that can override constructor settings
      * @returns Optimization result containing demos, stats, and configuration
      */
-    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
+    compile(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
     /**
      * Optimize a program with real-time streaming updates
      * @param program The program to optimize
@@ -3430,7 +3546,7 @@ interface AxOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * @param options Optional configuration options
      * @returns Async iterator yielding optimization progress
      */
-    compileStream?(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): AsyncIterableIterator<AxOptimizationProgress>;
+    compileStream?(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): AsyncIterableIterator<AxOptimizationProgress>;
     /**
      * Multi-objective optimization using Pareto frontier
      * @param program The program to optimize
@@ -3438,7 +3554,7 @@ interface AxOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * @param options Optional configuration options
      * @returns Pareto optimization result
      */
-    compilePareto?(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMultiMetricFn, options?: AxCompileOptions): Promise<AxParetoResult<OUT>>;
+    compilePareto?(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMultiMetricFn, options?: AxCompileOptions): Promise<AxParetoResult<OUT>>;
     /**
      * Get current optimization statistics
      * @returns Current optimization statistics
@@ -3468,7 +3584,7 @@ interface AxOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * @param program Program to validate
      * @returns Validation result with any issues found
      */
-    validateProgram?(program: Readonly<AxProgram<IN, OUT>>): {
+    validateProgram?(program: Readonly<AxGen<IN, OUT>>): {
         isValid: boolean;
         issues: string[];
         suggestions: string[];
@@ -3515,11 +3631,11 @@ interface AxMiPROOptimizerOptions {
 interface AxBootstrapCompileOptions extends AxCompileOptions {
     validationExamples?: readonly AxExample[];
     maxDemos?: number;
-    teacherProgram?: Readonly<AxProgram<AxGenIn, AxGenOut>>;
+    teacherProgram?: Readonly<AxGen<AxGenIn, AxGenOut>>;
 }
 interface AxMiPROCompileOptions extends AxCompileOptions {
     validationExamples?: readonly AxExample[];
-    teacher?: Readonly<AxProgram<AxGenIn, AxGenOut>>;
+    teacher?: Readonly<AxGen<AxGenIn, AxGenOut>>;
     auto?: 'light' | 'medium' | 'heavy';
     instructionCandidates?: string[];
     customProposer?: (context: Readonly<{
@@ -3563,6 +3679,8 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
     protected readonly resumeFromCheckpoint?: string;
     protected readonly logger?: AxLoggerFunction;
     protected readonly verbose?: boolean;
+    protected readonly debugOptimizer: boolean;
+    protected readonly optimizerLogger?: AxOptimizerLoggerFunction;
     private currentRound;
     private scoreHistory;
     private configurationHistory;
@@ -3627,23 +3745,15 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
     /**
      * Abstract method that must be implemented by concrete optimizers
      */
-    abstract compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
+    abstract compile(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
     /**
-     * Get current optimization statistics
-     */
-    getStats(): AxOptimizationStats;
-    /**
-     * Reset optimizer state for reuse with different programs
-     */
-    reset(): void;
-    /**
-     * Basic program validation that can be extended by concrete optimizers
+     * Optimize a program with real-time streaming updates
+     * @param program The program to optimize
+     * @param metricFn Evaluation metric function
+     * @param options Optional configuration options
+     * @returns Async iterator yielding optimization progress
      */
-    validateProgram(program: Readonly<AxProgram<IN, OUT>>): {
-        isValid: boolean;
-        issues: string[];
-        suggestions: string[];
-    };
+    compileStream(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): AsyncIterableIterator<AxOptimizationProgress>;
     /**
      * Multi-objective optimization using Pareto frontier
      * Default implementation that leverages the single-objective compile method
@@ -3652,7 +3762,7 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
      * @param options Optional configuration options
      * @returns Pareto optimization result with frontier of non-dominated solutions
      */
-    compilePareto(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMultiMetricFn, options?: AxCompileOptions): Promise<AxParetoResult<OUT>>;
+    compilePareto(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMultiMetricFn, options?: AxCompileOptions): Promise<AxParetoResult<OUT>>;
     /**
      * Generate solutions using different weighted combinations of objectives
      */
@@ -3711,8 +3821,7 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
      * Get the logger function with fallback hierarchy:
      * 1. Explicit logger passed to optimizer
      * 2. Logger from student AI service
-     * 3. Default optimizer logger
-     * 4. undefined if verbose is false
+     * 3. undefined if verbose is false
      */
     protected getLogger(options?: AxCompileOptions): AxLoggerFunction | undefined;
     /**
@@ -3751,11 +3860,15 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
      * Record performance metrics
      */
     protected recordPerformanceMetrics(metricType: 'evaluation' | 'demo_generation' | 'metric_computation', duration: number, optimizerType: string): void;
+    protected isOptimizerLoggingEnabled(options?: AxCompileOptions): boolean;
+    protected getOptimizerLogger(options?: AxCompileOptions): AxOptimizerLoggerFunction | undefined;
+    getStats(): AxOptimizationStats;
+    reset(): void;
 }
 
 type AxEvaluateArgs<IN extends AxGenIn, OUT extends AxGenOut> = {
     ai: AxAIService;
-    program: Readonly<AxProgram<IN, OUT>>;
+    program: Readonly<AxGen<IN, OUT>>;
     examples: Readonly<AxExample[]>;
 };
 declare class AxTestPrompt<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> {
@@ -3806,15 +3919,6 @@ declare class AxHFDataLoader {
 
 declare const axCreateDefaultColorLogger: (output?: (message: string) => void) => AxLoggerFunction;
 declare const axCreateDefaultTextLogger: (output?: (message: string) => void) => AxLoggerFunction;
-/**
- * Factory function to create an enhanced optimizer logger with clean visual formatting
- * that works for all optimizer types using semantic tags for proper categorization
- */
-declare const axCreateOptimizerLogger: (output?: (message: string) => void) => AxLoggerFunction;
-/**
- * Default optimizer logger instance
- */
-declare const axDefaultOptimizerLogger: AxLoggerFunction;
 
 interface AxMetricsConfig {
     enabled: boolean;
@@ -3866,6 +3970,19 @@ declare const axCheckMetricsHealth: () => {
 declare const axUpdateMetricsConfig: (config: Readonly<Partial<AxMetricsConfig>>) => void;
 declare const axGetMetricsConfig: () => AxMetricsConfig;
 
+/**
+ * Factory function to create a default optimizer logger with color formatting
+ */
+declare const axCreateDefaultOptimizerColorLogger: (output?: (message: string) => void) => AxOptimizerLoggerFunction;
+/**
+ * Factory function to create a text-only optimizer logger (no colors)
+ */
+declare const axCreateDefaultOptimizerTextLogger: (output?: (message: string) => void) => AxOptimizerLoggerFunction;
+/**
+ * Default optimizer logger instance with color formatting
+ */
+declare const axDefaultOptimizerLogger: AxOptimizerLoggerFunction;
+
 declare class AxBootstrapFewShot<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
     private maxRounds;
     private maxDemos;
@@ -3881,7 +3998,7 @@ declare class AxBootstrapFewShot<IN extends AxGenIn = AxGenIn, OUT extends AxGen
         options?: AxBootstrapOptimizerOptions;
     }>);
     private compileRound;
-    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxBootstrapCompileOptions): Promise<AxOptimizerResult<OUT>>;
+    compile(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxBootstrapCompileOptions): Promise<AxOptimizerResult<OUT>>;
 }
 
 interface AxMiPROResult<IN extends AxGenIn, OUT extends AxGenOut> extends AxOptimizerResult<OUT> {
@@ -3960,7 +4077,7 @@ declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
     /**
      * The main compile method to run MIPROv2 optimization
      */
-    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxMiPROResult<IN, OUT>>;
+    compile(program: Readonly<AxGen<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxMiPROResult<IN, OUT>>;
     /**
      * Applies a configuration to an AxGen instance
      */
@@ -3984,7 +4101,7 @@ declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * @param program Program to validate
      * @returns Validation result with any issues found
      */
-    validateProgram(program: Readonly<AxProgram<IN, OUT>>): {
+    validateProgram(_program: Readonly<AxGen<IN, OUT>>): {
         isValid: boolean;
         issues: string[];
         suggestions: string[];
@@ -4079,7 +4196,97 @@ declare const f: {
     };
 };
 
+/**
+ * Analyzes mapping functions to extract state dependencies.
+ *
+ * This class is crucial for the automatic parallelization feature of AxFlow.
+ * It determines which fields in the state object a mapping function accesses,
+ * which allows the execution planner to understand dependencies between steps
+ * and optimize execution by running independent steps in parallel.
+ *
+ * The analyzer uses two complementary approaches:
+ * 1. Static analysis of the function source code
+ * 2. Dynamic proxy-based tracking as a fallback
+ *
+ * This dual approach ensures robust dependency detection even for complex
+ * mapping functions that might use destructuring, computed property access,
+ * or other advanced JavaScript patterns.
+ */
+declare class AxFlowDependencyAnalyzer {
+    /**
+     * Analyzes a mapping function to determine which state fields it depends on.
+     *
+     * This method is called for every execute step to understand what data
+     * the step needs from the current state. This information is used to:
+     * - Build the dependency graph for parallel execution
+     * - Ensure steps execute in the correct order
+     * - Optimize performance by identifying independent operations
+     *
+     * The analysis process:
+     * 1. First tries static analysis by parsing the function source
+     * 2. Falls back to proxy-based tracking for complex cases
+     * 3. Returns a list of field names that the mapping function accesses
+     *
+     * @param mapping - The mapping function that transforms state to node inputs
+     * @param _nodeName - The name of the node (currently unused but kept for future use)
+     * @returns Array of field names that the mapping function depends on
+     *
+     * @example
+     * ```typescript
+     * // For a mapping like: state => ({ query: state.userInput, context: state.previousResult })
+     * // This would return: ['userInput', 'previousResult']
+     * ```
+     */
+    analyzeMappingDependencies(mapping: (state: any) => any, _nodeName: string): string[];
+    /**
+     * Creates a tracking proxy for dependency analysis.
+     *
+     * This is a public method that creates a proxy to track property access patterns.
+     * It's used for testing and advanced dependency analysis scenarios.
+     *
+     * @param target - The target object to wrap with a proxy
+     * @param accessed - Array to collect accessed property names
+     * @returns Proxy object that tracks property access
+     */
+    createTrackingProxy(target: any, accessed: string[]): any;
+    /**
+     * Parses function source code to extract state dependencies using static analysis.
+     *
+     * This method analyzes the source code of a function to find patterns like
+     * `state.fieldName` and extracts the field names as dependencies.
+     *
+     * @param functionSource - The source code of the function to analyze
+     * @returns Array of field names found in the source code
+     */
+    parseStaticDependencies(functionSource: string): string[];
+    /**
+     * Creates a proxy object that tracks property access for dependency analysis.
+     *
+     * This proxy intercepts all property access on the state object and records
+     * which fields are being accessed. It's used as a fallback when static analysis
+     * can't determine dependencies (e.g., for destructuring or computed properties).
+     *
+     * The proxy works by:
+     * 1. Intercepting all property access via the 'get' trap
+     * 2. Recording accessed property names in the dependencies array
+     * 3. Returning nested proxies for chained property access
+     *
+     * This allows detection of complex access patterns like:
+     * - Destructuring: const { field1, field2 } = state
+     * - Computed properties: state[dynamicKey]
+     * - Nested access: state.nested.field
+     *
+     * @param dependencies - Array to collect dependency names (modified in place)
+     * @returns Proxy object that tracks property access
+     */
+    private createDependencyTracker;
+}
+
 type AxFlowState = Record<string, unknown>;
+interface AxFlowNodeDefinition {
+    inputs: Record<string, unknown>;
+    outputs: Record<string, unknown>;
+}
 type AxFlowStepFunction = (state: AxFlowState, context: Readonly<{
     mainAi: AxAIService;
     mainOptions?: AxProgramForwardOptions;
@@ -4088,15 +4295,21 @@ interface AxFlowDynamicContext {
     ai?: AxAIService;
     options?: AxProgramForwardOptions;
 }
-type GetGenIn<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<infer IN, AxGenOut> ? IN : never;
-type GetGenOut<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<AxGenIn, infer OUT> ? OUT : never;
+type GetGenIn<T extends AxProgrammable<AxGenIn, AxGenOut>> = T extends AxProgrammable<infer IN, AxGenOut> ? IN : never;
+type GetGenOut<T extends AxProgrammable<AxGenIn, AxGenOut>> = T extends AxProgrammable<AxGenIn, infer OUT> ? OUT : never;
 type InferAxGen<TSig extends string> = TSig extends string ? AxGen<AxGenIn, AxGenOut> : never;
 type NodeResultKey<TNodeName extends string> = `${TNodeName}Result`;
 type AddNodeResult<TState extends AxFlowState, TNodeName extends string, TNodeOut extends AxGenOut> = TState & {
     [K in NodeResultKey<TNodeName>]: TNodeOut;
 };
-type AxFlowTypedParallelBranch<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> = (subFlow: AxFlowTypedSubContext<TNodes, TState>) => AxFlowTypedSubContext<TNodes, AxFlowState>;
-interface AxFlowTypedSubContext<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> {
+/**
+ * Interface for flows that can be tuned, executed, and used in compositions.
+ * Provides methods for building and executing complex AI workflows.
+ */
+interface AxFlowable<IN extends AxGenIn, OUT extends AxGenOut> extends AxProgrammable<IN, OUT> {
+}
+type AxFlowTypedParallelBranch<TNodes extends Record<string, AxProgrammable<any, any>>, TState extends AxFlowState> = (subFlow: AxFlowTypedSubContext<TNodes, TState>) => AxFlowTypedSubContext<TNodes, AxFlowState>;
+interface AxFlowTypedSubContext<TNodes extends Record<string, AxProgrammable<any, any>>, TState extends AxFlowState> {
     execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
     executeSteps(initialState: TState, context: Readonly<{
@@ -4113,8 +4326,13 @@ interface AxFlowSubContext {
         mainOptions?: AxProgramForwardOptions;
     }>): Promise<AxFlowState>;
 }
+interface AxFlowBranchContext {
+    predicate: (state: AxFlowState) => unknown;
+    branches: Map<unknown, AxFlowStepFunction[]>;
+    currentBranchValue?: unknown;
+}
 interface AxFlowExecutionStep {
-    type: 'execute' | 'map' | 'other';
+    type: 'execute' | 'map' | 'merge' | 'parallel-map' | 'parallel';
     nodeName?: string;
     dependencies: string[];
     produces: string[];
@@ -4125,6 +4343,207 @@ interface AxFlowParallelGroup {
     level: number;
     steps: AxFlowExecutionStep[];
 }
+interface AxFlowAutoParallelConfig {
+    enabled: boolean;
+    batchSize?: number;
+}
+
+/**
+ * Builds and manages the execution plan with automatic parallelization.
+ *
+ * This class is the core of AxFlow's performance optimization system.
+ * It analyzes the dependency relationships between steps and creates
+ * an optimized execution plan that maximizes parallelism while ensuring
+ * correct execution order.
+ *
+ * Key responsibilities:
+ * 1. **Dependency Analysis**: Tracks what fields each step depends on and produces
+ * 2. **Parallel Grouping**: Groups independent steps that can run simultaneously
+ * 3. **Execution Optimization**: Creates optimized execution functions that
+ *    run parallel groups concurrently
+ * 4. **Signature Inference**: Provides data for automatic signature generation
+ *
+ * The planner works by building a directed acyclic graph (DAG) of dependencies
+ * and then creating execution levels where all steps in a level can run in parallel.
+ */
+declare class AxFlowExecutionPlanner {
+    private steps;
+    private parallelGroups;
+    private readonly analyzer;
+    private initialFields;
+    /**
+     * Adds an execution step to the plan for analysis and optimization.
+     *
+     * This method is called for every operation in the flow (execute, map, merge, etc.)
+     * and performs dependency analysis to understand what the step needs and produces.
+     * This information is crucial for building the parallel execution plan.
+     *
+     * The method handles different types of steps:
+     * - **Execute steps**: LLM node operations that depend on specific state fields
+     * - **Map steps**: Transformations that modify the state object
+     * - **Merge steps**: Operations that combine results from branches or parallel operations
+     * - **Other steps**: Generic operations that don't fit other categories
+     *
+     * @param stepFunction - The actual function to execute for this step
+     * @param nodeName - Name of the node (for execute steps)
+     * @param mapping - Function that maps state to node inputs (for execute steps)
+     * @param stepType - Type of step for specialized analysis
+     * @param mapTransform - Transformation function (for map steps)
+     * @param mergeOptions - Options for merge operations (result key, merge function)
+     */
+    addExecutionStep(stepFunction: AxFlowStepFunction, nodeName?: string, mapping?: (state: any) => any, stepType?: 'execute' | 'map' | 'merge' | 'parallel-map' | 'parallel', mapTransform?: (state: any) => any, mergeOptions?: {
+        resultKey?: string;
+        mergeFunction?: (...args: any[]) => any;
+    }): void;
+    /**
+     * Analyzes a map transformation function to determine what fields it produces.
+     *
+     * This is a challenging problem because map transformations can produce arbitrary
+     * new fields based on complex logic. The method uses a mock state approach:
+     * 1. Creates a mock state with sample data
+     * 2. Runs the transformation on the mock state
+     * 3. Analyzes the result to see what fields were produced
+     *
+     * This approach works for most common transformation patterns but may miss
+     * edge cases where the transformation behavior depends on specific data values.
+     *
+     * @param mapTransform - The map transformation function to analyze
+     * @returns Array of field names that the transformation produces
+     */
+    private analyzeMapTransformation;
+    /**
+     * Creates a mock state with sample data for transformation analysis.
+     *
+     * This method builds a representative state object that includes:
+     * - Initial fields from the flow input
+     * - Result fields from previous steps with realistic structure
+     * - Sample data that allows transformations to execute
+     *
+     * The mock state is used to run map transformations in a controlled
+     * environment to determine what fields they produce.
+     *
+     * @returns Mock state object with sample data
+     */
+    private createMockState;
+    /**
+     * Creates appropriate mock values based on field names and patterns.
+     */
+    private createMockValue;
+    /**
+     * Analyzes what fields are produced by conditional merge operations.
+     *
+     * Conditional merges are complex because they don't transform data like map operations,
+     * but instead select which branch's results to use based on a condition.
+     * The challenge is determining what fields will be available after the merge
+     * without knowing which branch will be taken at runtime.
+     *
+     * This method uses heuristics to determine the likely output fields:
+     * 1. Look at recent execute steps (likely branch operations)
+     * 2. If found, use their output fields as potential merge results
+     * 3. Fallback to all execute step fields if no recent pattern is found
+     *
+     * The analysis assumes that branches in a conditional merge will produce
+     * similar types of fields, so we can use any branch's fields as representative
+     * of what the merge might produce.
+     *
+     * @returns string[] - Array of field names that the merge operation might produce
+     */
+    private analyzeBranchMergeFields;
+    /**
+     * Sets the initial fields and triggers parallel group rebuilding.
+     *
+     * This method is called once the flow knows what input fields are available.
+     * It triggers the parallel group analysis which determines the optimal
+     * execution strategy for the entire flow.
+     *
+     * @param fields - Array of field names available at the start of execution
+     */
+    setInitialFields(fields: string[]): void;
+    /**
+     * Rebuilds the parallel execution groups based on step dependencies.
+     *
+     * This is the core algorithm that creates the parallel execution plan.
+     * It uses a level-by-level approach:
+     *
+     * 1. **Level 0**: Steps with no dependencies (can run immediately)
+     * 2. **Level 1**: Steps that depend only on Level 0 outputs
+     * 3. **Level N**: Steps that depend on outputs from previous levels
+     *
+     * Steps within the same level can run in parallel because they don't
+     * depend on each other's outputs.
+     *
+     * The algorithm ensures:
+     * - Correct execution order (dependencies are satisfied)
+     * - Maximum parallelism (independent steps run simultaneously)
+     * - Deadlock prevention (circular dependencies are detected)
+     *
+     * Time complexity: O(n²) where n is the number of steps
+     * Space complexity: O(n) for tracking processed steps and available fields
+     */
+    private rebuildParallelGroups;
+    /**
+     * Gets all fields produced by previous steps.
+     *
+     * This is used by steps that depend on "everything produced so far"
+     * such as map transformations and merge operations.
+     *
+     * @returns Array of all field names produced by previous steps
+     */
+    private getAllProducedFields;
+    /**
+     * Creates optimized execution functions that implement the parallel execution plan.
+     *
+     * This method converts the parallel groups into actual executable functions.
+     * It creates a series of steps where:
+     * - Single-step groups execute directly
+     * - Multi-step groups execute in parallel with batch size control
+     * - Results are properly merged to maintain state consistency
+     *
+     * The optimized execution can significantly improve performance for flows
+     * with independent operations, especially I/O-bound operations like LLM calls.
+     *
+     * Performance benefits:
+     * - Reduces total execution time for independent operations
+     * - Maximizes CPU and I/O utilization
+     * - Maintains correctness through dependency management
+     * - Controls resource usage through batch size limiting
+     *
+     * @param batchSize - Maximum number of concurrent operations (optional)
+     * @returns Array of optimized step functions ready for execution
+     */
+    createOptimizedExecution(batchSize?: number): AxFlowStepFunction[];
+    /**
+     * Gets optimized execution steps for the flow.
+     *
+     * This method provides the optimized execution steps that can be used
+     * to execute the flow with maximum parallelism while maintaining
+     * dependency order.
+     *
+     * @returns Array of optimized step functions ready for execution
+     */
+    getOptimizedExecutionSteps(): AxFlowStepFunction[];
+    /**
+     * Gets detailed execution plan information for debugging and analysis.
+     *
+     * This method provides comprehensive information about the execution plan,
+     * including step counts, parallel grouping details, and the complete
+     * dependency structure. It's particularly useful for:
+     * - Debugging execution flow issues
+     * - Performance analysis and optimization
+     * - Understanding parallelization effectiveness
+     * - Monitoring execution plan complexity
+     *
+     * @returns Object containing detailed execution plan metrics and data
+     */
+    getExecutionPlan(): {
+        totalSteps: number;
+        parallelGroups: number;
+        maxParallelism: number;
+        steps: AxFlowExecutionStep[];
+        groups: AxFlowParallelGroup[];
+    };
+}
+
 /**
  * AxFlow - A fluent, chainable API for building and orchestrating complex, stateful AI programs.
  *
@@ -4143,8 +4562,8 @@ interface AxFlowParallelGroup {
  * const result = await flow.forward(ai, { topic: "AI safety" })
  * ```
  */
-declare class AxFlow<IN extends AxGenIn, OUT extends AxGenOut, TNodes extends Record<string, AxGen<any, any>> = Record<string, never>, // Node registry for type tracking
-TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
+declare class AxFlow<IN extends AxGenIn, OUT extends AxGenOut, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, // Node registry for type tracking
+TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     private readonly nodes;
     private readonly flowDefinition;
     private readonly nodeGenerators;
@@ -4153,9 +4572,80 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
     private branchContext;
     private readonly autoParallelConfig;
     private readonly executionPlanner;
-    constructor(signature?: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: {
+    private program?;
+    /**
+     * Converts a string to camelCase for valid field names
+     */
+    private toCamelCase;
+    /**
+     * Infers the signature of the flow based on the execution plan and node definitions.
+     * This is the core method that determines what input/output fields the flow should have
+     * based on the nodes and operations defined in the flow.
+     *
+     * The inference process follows these steps:
+     * 1. If no nodes are defined, return a default signature
+     * 2. Analyze the execution plan to find all produced and consumed fields
+     * 3. Determine input fields (consumed but not produced by any step)
+     * 4. Determine output fields with special handling for final map/merge operations
+     * 5. If no clear pattern is found, create a comprehensive signature from all nodes
+     *
+     * Special handling for final operations:
+     * - Map operations: Use the fields produced by the map transformation
+     * - Merge operations: Use fields from the merged branches or merge result
+     * - Conditional merges: Analyze what fields the branches actually produce
+     *
+     * @returns AxSignature - The inferred signature for this flow
+     */
+    private inferSignatureFromFlow;
+    constructor(options?: {
         autoParallel?: boolean;
+        batchSize?: number;
     });
+    /**
+     * Initializes the program field every time something is  added to the graph
+     */
+    private ensureProgram;
+    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
+    setId(id: string): void;
+    setParentId(parentId: string): void;
+    getTraces(): AxProgramTrace<IN, OUT>[];
+    setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
+    getUsage(): AxProgramUsage[];
+    resetUsage(): void;
+    streamingForward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
+    /**
+     * Executes the flow with the given AI service and input values.
+     *
+     * This is the main execution method that orchestrates the entire flow execution.
+     * It handles several complex aspects:
+     *
+     * 1. **Dynamic Signature Inference**: If the flow was created with a default signature
+     *    but has nodes defined, it will infer the actual signature from the flow structure.
+     *
+     * 2. **Execution Mode Selection**: Chooses between optimized parallel execution
+     *    (when auto-parallel is enabled) or sequential execution based on configuration.
+     *
+     * 3. **State Management**: Maintains the evolving state object as it flows through
+     *    each step, accumulating results and transformations.
+     *
+     * 4. **Performance Optimization**: Uses the execution planner to identify
+     *    independent operations that can run in parallel, reducing total execution time.
+     *
+     * Execution Flow:
+     * - Initialize state with input values
+     * - Infer signature if needed (based on nodes and current signature)
+     * - Choose execution strategy (parallel vs sequential)
+     * - Execute all steps while maintaining state consistency
+     * - Return final state cast to expected output type
+     *
+     * @param ai - The AI service to use as the default for all steps
+     * @param values - The input values for the flow
+     * @param options - Optional forward options to use as defaults (includes autoParallel override)
+     * @returns Promise that resolves to the final output
+     */
+    forward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions & {
+        autoParallel?: boolean;
+    }>): Promise<OUT>;
     /**
      * Declares a reusable computational node using a signature string.
      * Returns a new AxFlow type that tracks this node in the TNodes registry.
@@ -4194,24 +4684,6 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
         [K in TName]: AxGen<AxGenIn, AxGenOut>;
     }, // Add new node to registry
     TState>;
-    /**
-     * Declares a reusable computational node using an existing AxGen instance.
-     * This allows reusing pre-configured generators in the flow.
-     *
-     * @param name - The name of the node
-     * @param axgenInstance - Existing AxGen instance to use for this node
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```typescript
-     * const summarizer = new AxGen('text:string -> summary:string', { temperature: 0.1 })
-     * flow.node('summarizer', summarizer)
-     * ```
-     */
-    node<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: TGen;
-    }, // Add new node to registry with exact type
-    TState>;
     /**
      * Declares a reusable computational node using a class that extends AxProgram.
      * This allows using custom program classes in the flow.
@@ -4228,10 +4700,22 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * flow.node('custom', CustomProgram)
      * ```
      */
-    node<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
+    node<TName extends string, TProgram extends new () => AxProgrammable<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
         [K in TName]: InstanceType<TProgram>;
     }, // Add new node to registry with exact type
     TState>;
+    /**
+     * Declares a reusable computational node using an AxProgrammable instance.
+     * This allows using pre-configured AxGen instances or other programmable objects in the flow.
+     *
+     * @param name - The name of the node
+     * @param programInstance - The AxProgrammable instance to use for this node
+     * @returns New AxFlow instance with updated TNodes type
+     */
+    node<TName extends string, TProgram extends AxProgrammable<any, any>>(name: TName, programInstance: TProgram): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: TProgram;
+    }, // Add new node to registry with exact type
+    TState>;
     /**
      * Short alias for node() - supports signature strings, AxSignature instances, AxGen instances, and program classes
      */
@@ -4241,12 +4725,12 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
     n<TName extends string>(name: TName, signature: AxSignature, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
         [K in TName]: AxGen<AxGenIn, AxGenOut>;
     }, TState>;
-    n<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: TGen;
-    }, TState>;
-    n<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
+    n<TName extends string, TProgram extends new () => AxProgrammable<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
         [K in TName]: InstanceType<TProgram>;
     }, TState>;
+    n<TName extends string, TProgram extends AxProgrammable<any, any>>(name: TName, programInstance: TProgram): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: TProgram;
+    }, TState>;
     /**
      * Applies a synchronous transformation to the state object.
      * Returns a new AxFlow type with the evolved state.
@@ -4259,11 +4743,39 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
      * ```
      */
-    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
+    map<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
     /**
-     * Short alias for map()
+     * Applies a transformation to the state object with optional parallel execution.
+     * When parallel is enabled, the transform function should prepare data for parallel processing.
+     * The actual parallel processing happens with the array of transforms provided.
+     *
+     * @param transforms - Array of transformation functions to apply in parallel
+     * @param options - Options including parallel execution configuration
+     * @returns New AxFlow instance with updated TState type
+     *
+     * @example
+     * ```typescript
+     * // Parallel map with multiple transforms
+     * flow.map([
+     *   state => ({ ...state, result1: processA(state.data) }),
+     *   state => ({ ...state, result2: processB(state.data) }),
+     *   state => ({ ...state, result3: processC(state.data) })
+     * ], { parallel: true })
+     * ```
      */
-    m<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
+    map<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => TNewState>, options: {
+        parallel: true;
+    }): AxFlow<IN, OUT, TNodes, TNewState>;
+    map<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState, options?: {
+        parallel?: boolean;
+    }): AxFlow<IN, OUT, TNodes, TNewState>;
+    /**
+     * Short alias for map() - supports parallel option
+     */
+    m<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
+    m<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => TNewState>, options: {
+        parallel: true;
+    }): AxFlow<IN, OUT, TNodes, TNewState>;
     /**
      * Labels a step for later reference (useful for feedback loops).
      *
@@ -4295,11 +4807,11 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
      * ```
      */
-    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
+    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (_state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     /**
      * Short alias for execute()
      */
-    e<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
+    e<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (_state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     /**
      * Starts a conditional branch based on a predicate function.
      *
@@ -4316,11 +4828,11 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      *   .merge()
      * ```
      */
-    branch(predicate: (state: TState) => unknown): this;
+    branch(predicate: (_state: TState) => unknown): this;
     /**
      * Short alias for branch()
      */
-    b(predicate: (state: TState) => unknown): this;
+    b(predicate: (_state: TState) => unknown): this;
     /**
      * Defines a branch case for the current branch context.
      *
@@ -4333,25 +4845,34 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      */
     w(value: unknown): this;
     /**
-     * Ends the current branch and merges all branch paths back into the main flow.
-     * Optionally specify the explicit merged state type for better type safety.
+     * Merges the results of conditional branches into a single execution path.
+     *
+     * This method is called after defining conditional branches with branch() and when() methods.
+     * It creates a merge point where the flow continues with the results from whichever
+     * branch was executed based on the branch condition.
+     *
+     * How conditional merging works:
+     * 1. The branch predicate is evaluated against the current state
+     * 2. The matching branch's steps are executed sequentially
+     * 3. If no branch matches, the state is returned unchanged
+     * 4. The merged result becomes the new state for subsequent steps
      *
-     * @param explicitMergedType - Optional type hint for the merged state (defaults to current TState)
-     * @returns AxFlow instance with the merged state type
+     * Type safety note:
+     * The TMergedState generic allows for type-level tracking of what fields
+     * will be available after the merge, though runtime behavior depends on
+     * which branch actually executes.
+     *
+     * @returns AxFlow with updated state type reflecting the merged result
      *
      * @example
      * ```typescript
-     * // Default behavior - preserves current TState
-     * flow.branch(state => state.type)
-     *   .when('simple').execute('simpleProcessor', ...)
-     *   .when('complex').execute('complexProcessor', ...)
-     *   .merge()
-     *
-     * // Explicit type - specify exact merged state shape
-     * flow.branch(state => state.type)
-     *   .when('simple').map(state => ({ result: state.simpleResult, method: 'simple' }))
-     *   .when('complex').map(state => ({ result: state.complexResult, method: 'complex' }))
-     *   .merge<{ result: string; method: string }>()
+     * flow
+     *   .branch(state => state.complexity > 0.5)
+     *   .when(true)
+     *     .execute('complexProcessor', state => ({ input: state.text }))
+     *   .when(false)
+     *     .execute('simpleProcessor', state => ({ input: state.text }))
+     *   .merge() // Combines results from either branch
      * ```
      */
     merge<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
@@ -4360,8 +4881,24 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      */
     mg<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
     /**
-     * Executes multiple operations in parallel and merges their results.
-     * Both typed and legacy untyped branches are supported.
+     * Executes multiple operations in parallel and provides a merge method for combining results.
+     *
+     * This method enables true parallel execution of independent operations, which is particularly
+     * useful for operations like:
+     * - Multiple document retrievals
+     * - Parallel processing of different data sources
+     * - Independent LLM calls that can run simultaneously
+     *
+     * How parallel execution works:
+     * 1. Each branch function receives a sub-context for defining operations
+     * 2. All branches are executed simultaneously using Promise.all()
+     * 3. Results are stored in _parallelResults for the merge operation
+     * 4. The merge function combines the results into a single field
+     *
+     * Performance benefits:
+     * - Reduces total execution time for independent operations
+     * - Maximizes throughput for I/O-bound operations (like LLM calls)
+     * - Maintains type safety through the merge operation
      *
      * @param branches - Array of functions that define parallel operations
      * @returns Object with merge method for combining results
@@ -4376,7 +4913,7 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * ```
      */
     parallel(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
-        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
+        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (..._results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
             [K in TResultKey]: T;
         }>;
     };
@@ -4384,7 +4921,7 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * Short alias for parallel()
      */
     p(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
-        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
+        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (..._results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
             [K in TResultKey]: T;
         }>;
     };
@@ -4404,11 +4941,11 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      *   .feedback(state => state.qualityCheckResult.confidence < 0.7, 'retry-point')
      * ```
      */
-    feedback(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
+    feedback(condition: (_state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
     /**
      * Short alias for feedback()
      */
-    fb(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
+    fb(condition: (_state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
     /**
      * Marks the beginning of a loop block.
      *
@@ -4427,7 +4964,7 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
     /**
      * Short alias for while()
      */
-    wh(condition: (state: TState) => boolean, maxIterations?: number): this;
+    wh(condition: (_state: TState) => boolean, maxIterations?: number): this;
     /**
      * Marks the end of a loop block.
      *
@@ -4438,17 +4975,6 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
      * Short alias for endWhile()
      */
     end(): this;
-    /**
-     * Executes the flow with the given AI service and input values.
-     *
-     * @param ai - The AI service to use as the default for all steps
-     * @param values - The input values for the flow
-     * @param options - Optional forward options to use as defaults (includes autoParallel override)
-     * @returns Promise that resolves to the final output
-     */
-    forward(ai: Readonly<AxAIService>, values: IN, options?: Readonly<AxProgramForwardOptions & {
-        autoParallel?: boolean;
-    }>): Promise<OUT>;
     /**
      * Gets execution plan information for debugging automatic parallelization
      *
@@ -4462,6 +4988,22 @@ TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
         steps?: AxFlowExecutionStep[];
         groups?: AxFlowParallelGroup[];
     };
+    getSignature(): AxSignature;
+}
+
+/**
+ * Implementation of the sub-context for parallel execution
+ */
+declare class AxFlowSubContextImpl implements AxFlowSubContext {
+    private readonly nodeGenerators;
+    private readonly steps;
+    constructor(nodeGenerators: Map<string, AxForwardable<AxGenIn, AxGenOut> & AxTunable<AxGenIn, AxGenOut> & AxUsable>);
+    execute(nodeName: string, mapping: (state: AxFlowState) => Record<string, AxFieldValue>, dynamicContext?: AxFlowDynamicContext): this;
+    map(transform: (state: AxFlowState) => AxFlowState): this;
+    executeSteps(initialState: AxFlowState, context: Readonly<{
+        mainAi: AxAIService;
+        mainOptions?: AxProgramForwardOptions;
+    }>): Promise<AxFlowState>;
 }
 /**
  * Typed implementation of the sub-context for parallel execution with full type safety
@@ -4596,18 +5138,18 @@ declare class AxEmbeddingAdapter {
     toFunction(): AxFunction;
 }
 
-interface JSONRPCRequest<T> {
+interface AxMCPJSONRPCRequest<T> {
     jsonrpc: '2.0';
     id: string | number;
     method: string;
     params?: T;
 }
-interface JSONRPCSuccessResponse<T = unknown> {
+interface AxMCPJSONRPCSuccessResponse<T = unknown> {
     jsonrpc: '2.0';
     id: string | number;
     result: T;
 }
-interface JSONRPCErrorResponse {
+interface AxMCPJSONRPCErrorResponse {
     jsonrpc: '2.0';
     id: string | number;
     error: {
@@ -4616,8 +5158,38 @@ interface JSONRPCErrorResponse {
         data?: unknown;
     };
 }
-type JSONRPCResponse<T = unknown> = JSONRPCSuccessResponse<T> | JSONRPCErrorResponse;
-interface JSONRPCNotification {
+type AxMCPJSONRPCResponse<T = unknown> = AxMCPJSONRPCSuccessResponse<T> | AxMCPJSONRPCErrorResponse;
+interface AxMCPInitializeParams {
+    protocolVersion: string;
+    capabilities: Record<string, unknown>;
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface AxMCPInitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: unknown[];
+        resources?: Record<string, unknown>;
+        prompts?: unknown[];
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+interface AxMCPFunctionDescription {
+    name: string;
+    description: string;
+    inputSchema: AxFunctionJSONSchema;
+}
+interface AxMCPToolsListResult {
+    name: string;
+    description: string;
+    tools: AxMCPFunctionDescription[];
+}
+interface AxMCPJSONRPCNotification {
     jsonrpc: '2.0';
     method: string;
     params?: Record<string, unknown>;
@@ -4629,12 +5201,12 @@ interface AxMCPTransport {
      * @param message The JSON-RPC request or notification to send
      * @returns A Promise that resolves to the JSON-RPC response
      */
-    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    send(message: Readonly<AxMCPJSONRPCRequest<unknown>>): Promise<AxMCPJSONRPCResponse<unknown>>;
     /**
      * Sends a JSON-RPC notification
      * @param message The JSON-RPC notification to send
      */
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    sendNotification(message: Readonly<AxMCPJSONRPCNotification>): Promise<void>;
     /**
      * Connects to the transport if needed
      * This method is optional and only required for transports that need connection setup
@@ -4707,8 +5279,8 @@ declare class AxMCPHTTPSSETransport implements AxMCPTransport {
     private eventSource?;
     constructor(sseUrl: string);
     connect(): Promise<void>;
-    send(message: JSONRPCRequest<unknown> | JSONRPCNotification): Promise<JSONRPCResponse<unknown>>;
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    send(message: AxMCPJSONRPCRequest<unknown> | AxMCPJSONRPCNotification): Promise<AxMCPJSONRPCResponse<unknown>>;
+    sendNotification(message: Readonly<AxMCPJSONRPCNotification>): Promise<void>;
 }
 interface AxMCPStreamableHTTPTransportOptions {
     /**
@@ -4753,7 +5325,7 @@ declare class AxMCPStreambleHTTPTransport implements AxMCPTransport {
     /**
      * Set a handler for incoming server messages (requests/notifications)
      */
-    setMessageHandler(handler: (message: JSONRPCRequest<unknown> | JSONRPCNotification) => void): void;
+    setMessageHandler(handler: (message: AxMCPJSONRPCRequest<unknown> | AxMCPJSONRPCNotification) => void): void;
     connect(): Promise<void>;
     /**
      * Opens an SSE stream to listen for server-initiated messages
@@ -4763,9 +5335,9 @@ declare class AxMCPStreambleHTTPTransport implements AxMCPTransport {
      * Opens an SSE stream using fetch API to support custom headers
      */
     private openListeningStreamWithFetch;
-    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    send(message: Readonly<AxMCPJSONRPCRequest<unknown>>): Promise<AxMCPJSONRPCResponse<unknown>>;
     private handleSSEResponse;
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    sendNotification(message: Readonly<AxMCPJSONRPCNotification>): Promise<void>;
     /**
      * Explicitly terminate the session (if supported by server)
      */
@@ -4780,7 +5352,7 @@ declare class AxMCPStreambleHTTPTransport implements AxMCPTransport {
  * Interface for agents that can be used as child agents.
  * Provides methods to get the agent's function definition and features.
  */
-interface AxAgentic<IN extends AxGenIn, OUT extends AxGenOut> extends AxTunable<IN, OUT>, AxUsable {
+interface AxAgentic<IN extends AxGenIn, OUT extends AxGenOut> extends AxProgrammable<IN, OUT> {
     getFunction(): AxFunction;
     getFeatures(): AxAgentFeatures;
 }
@@ -4846,6 +5418,8 @@ declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAge
      */
     setDescription(description: string): void;
     setDefinition(definition: string): void;
+    getSignature(): AxSignature;
+    setSignature(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>): void;
     private getDebug;
 }
 
@@ -4949,4 +5523,4 @@ declare class AxRateLimiterTokenUsage {
     acquire(tokens: number): Promise<void>;
 }
 
-export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, type AxAIPromptConfig, AxAIRefusalError, AxAIReka, type AxAIRekaArgs, type AxAIRekaChatRequest, type AxAIRekaChatResponse, type AxAIRekaChatResponseDelta, type AxAIRekaConfig, AxAIRekaModel, type AxAIRekaUsage, type AxAIService, AxAIServiceAbortedError, type AxAIServiceActionOptions, AxAIServiceAuthenticationError, AxAIServiceError, type AxAIServiceImpl, type AxAIServiceMetrics, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, AxAITogether, type AxAITogetherArgs, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, AxChainOfThought, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type AxFieldDescriptor, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, AxFlowTypedSubContextImpl, type AxFunction, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, type AxFunctionResultFormatter, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenMetricsInstruments, type AxGenOut, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, AxLLMRequestTypeValues, type AxLoggerFunction, type AxLoggerTag, AxMCPClient, AxMCPHTTPSSETransport, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPTransport, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramTrace, type AxProgramUsage, AxPromptTemplate, type AxPromptTemplateOptions, AxRAG, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, type AxSignatureConfig, type AxSignatureTemplateValue, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultColorLogger, axCreateDefaultTextLogger, axCreateOptimizerLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, f, s };
+export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, type AxAIPromptConfig, AxAIRefusalError, AxAIReka, type AxAIRekaArgs, type AxAIRekaChatRequest, type AxAIRekaChatResponse, type AxAIRekaChatResponseDelta, type AxAIRekaConfig, AxAIRekaModel, type AxAIRekaUsage, type AxAIService, AxAIServiceAbortedError, type AxAIServiceActionOptions, AxAIServiceAuthenticationError, AxAIServiceError, type AxAIServiceImpl, type AxAIServiceMetrics, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, AxAITogether, type AxAITogetherArgs, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, AxChainOfThought, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type AxFieldDescriptor, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, type AxFlowAutoParallelConfig, type AxFlowBranchContext, AxFlowDependencyAnalyzer, type AxFlowDynamicContext, AxFlowExecutionPlanner, type AxFlowExecutionStep, type AxFlowNodeDefinition, type AxFlowParallelBranch, type AxFlowParallelGroup, type AxFlowState, type AxFlowStepFunction, type AxFlowSubContext, AxFlowSubContextImpl, type AxFlowTypedParallelBranch, type AxFlowTypedSubContext, AxFlowTypedSubContextImpl, type AxFlowable, type AxForwardable, type AxFunction, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, type AxFunctionResultFormatter, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenMetricsInstruments, type AxGenOut, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, AxLLMRequestTypeValues, type AxLoggerData, type AxLoggerFunction, AxMCPClient, type AxMCPFunctionDescription, AxMCPHTTPSSETransport, type AxMCPInitializeParams, type AxMCPInitializeResult, type AxMCPJSONRPCErrorResponse, type AxMCPJSONRPCNotification, type AxMCPJSONRPCRequest, type AxMCPJSONRPCResponse, type AxMCPJSONRPCSuccessResponse, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPToolsListResult, type AxMCPTransport, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerLoggerData, type AxOptimizerLoggerFunction, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramTrace, type AxProgramUsage, type AxProgrammable, AxPromptTemplate, type AxPromptTemplateOptions, AxRAG, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, type AxSignatureConfig, type AxSignatureTemplateValue, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultColorLogger, axCreateDefaultOptimizerColorLogger, axCreateDefaultOptimizerTextLogger, axCreateDefaultTextLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, f, s };