@ax-llm/ax 21.0.14 → 22.0.0

package/index.d.ts

@@ -86,9 +86,11 @@ declare class AxAIRefusalError extends Error {
     readonly refusalMessage: string;
     readonly model?: string | undefined;
     readonly requestId?: string | undefined;
+    readonly category?: string | null | undefined;
+    readonly explanation?: string | null | undefined;
     readonly timestamp: string;
     readonly errorId: string;
-    constructor(refusalMessage: string, model?: string | undefined, requestId?: string | undefined);
+    constructor(refusalMessage: string, model?: string | undefined, requestId?: string | undefined, category?: string | null | undefined, explanation?: string | null | undefined);
     toString(): string;
 }
 /**
@@ -505,6 +507,14 @@ type AxModelInfo = {
     longContextCacheReadTokenCostPer1M?: number;
     /** Total input token count (including cached) above which long-context rates apply */
     longContextThreshold?: number;
+    /** Prompt token cost when a provider speed tier such as Anthropic fast mode is active. */
+    fastPromptTokenCostPer1M?: number;
+    /** Completion token cost when a provider speed tier such as Anthropic fast mode is active. */
+    fastCompletionTokenCostPer1M?: number;
+    /** Cache read token cost when a provider speed tier such as Anthropic fast mode is active. */
+    fastCacheReadTokenCostPer1M?: number;
+    /** Cache write token cost when a provider speed tier such as Anthropic fast mode is active. */
+    fastCacheWriteTokenCostPer1M?: number;
     aliases?: string[];
     supported?: {
         thinkingBudget?: boolean;
@@ -535,6 +545,7 @@ type AxTokenUsage = {
     cacheCreationTokens?: number;
     cacheReadTokens?: number;
     serviceTier?: 'standard' | 'priority' | 'batch';
+    speed?: 'standard' | 'fast';
 };
 /**
  * Configuration options for AI model behavior.
@@ -659,6 +670,16 @@ type AxModelConfig = {
      * @example 3 to generate three alternatives and pick the best
      */
     n?: number;
+    /** Provider reasoning/effort hint. Currently used by Anthropic. */
+    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+    /** Provider speed tier. Currently used by Anthropic fast mode. */
+    speed?: 'standard' | 'fast';
+    /** Advisory full-task token budget. Currently used by Anthropic Opus task budgets. */
+    taskBudget?: {
+        type: 'tokens';
+        total: number;
+        remaining?: number;
+    };
 };
 type AxFunctionHandler = (args?: any, extra?: Readonly<{
     sessionId?: string;
@@ -972,17 +993,11 @@ interface AxAIServiceMetrics {
     };
 }
 type AxInternalChatRequest<TModel> = Omit<AxChatRequest, 'model'> & Required<Pick<AxChatRequest<TModel>, 'model'>>;
-type AxInternalTranscriptionRequest<TModel> = Omit<AxTranscriptionRequest, 'model'> & {
-    model?: TModel;
-};
 type AxEmbedRequest<TEmbedModel = string> = {
     texts?: readonly string[];
     embedModel?: TEmbedModel;
 };
 type AxInternalEmbedRequest<TEmbedModel> = Omit<AxEmbedRequest, 'embedModel'> & Required<Pick<AxEmbedRequest<TEmbedModel>, 'embedModel'>>;
-type AxInternalSpeechRequest<TModel> = Omit<AxSpeechRequest, 'model'> & {
-    model?: TModel;
-};
 type AxRateLimiterFunction = <T = unknown>(reqFunc: () => Promise<T | ReadableStream<T>>, info: Readonly<{
     modelUsage?: AxModelUsage;
 }>) => Promise<T | ReadableStream<T>>;
@@ -1016,11 +1031,6 @@ type AxLoggerData = {
     index: number;
     fixingInstructions: string;
     error: unknown;
-} | {
-    name: 'AssertionError';
-    index: number;
-    fixingInstructions: string;
-    error: unknown;
 } | {
     name: 'RefusalError';
     index: number;
@@ -1305,15 +1315,6 @@ type AxAIServiceOptions = {
      * **Currently supported by:** Google Gemini/Vertex AI
      */
     contextCache?: AxContextCacheOptions;
-    /**
-     * Render examples/demos in the system prompt instead of as message pairs.
-     *
-     * - `false` (default) - Examples rendered as alternating user/assistant messages
-     * - `true` - Examples embedded in system prompt (legacy behavior)
-     *
-     * Message pair rendering generally produces better results.
-     */
-    examplesInSystem?: boolean;
     /**
      * Custom labels for OpenTelemetry metrics.
      *
@@ -1455,6 +1456,224 @@ interface AxAIMemory {
     removeByTag(name: string, sessionId?: string): AxMemoryData;
 }
 
+declare class AxMemory implements AxAIMemory {
+    private memories;
+    private defaultMemory;
+    constructor();
+    private getMemory;
+    addRequest(value: AxChatRequest['chatPrompt'], sessionId?: string): void;
+    addResponse(results: Readonly<AxChatResponseResult[]>, sessionId?: string): void;
+    addFunctionResults(results: Readonly<AxFunctionResult[]>, sessionId?: string): void;
+    updateResult(result: Readonly<AxChatResponseResult & {
+        delta?: string;
+    }>, sessionId?: string): void;
+    addTag(name: string, sessionId?: string): void;
+    rewindToTag(name: string, sessionId?: string): AxMemoryData;
+    removeByTag(name: string, sessionId?: string): AxMemoryData;
+    history(index: number, sessionId?: string): ({
+        role: "system";
+        content: string;
+        cache?: boolean;
+    } | {
+        role: "user";
+        name?: string;
+        content: string | ({
+            type: "text";
+            text: string;
+            cache?: boolean;
+        } | {
+            type: "image";
+            mimeType: string;
+            image: string;
+            details?: "high" | "low" | "auto";
+            cache?: boolean;
+            optimize?: "quality" | "size" | "auto";
+            altText?: string;
+        } | {
+            type: "audio";
+            data: string;
+            format?: AxAudioFormat;
+            mimeType?: string;
+            sampleRate?: number;
+            channels?: number;
+            cache?: boolean;
+            transcription?: string;
+            duration?: number;
+        } | {
+            type: "file";
+            data: string;
+            filename?: string;
+            mimeType: string;
+            cache?: boolean;
+            extractedText?: string;
+        } | {
+            type: "file";
+            fileUri: string;
+            filename?: string;
+            mimeType: string;
+            cache?: boolean;
+            extractedText?: string;
+        } | {
+            type: "url";
+            url: string;
+            cache?: boolean;
+            cachedContent?: string;
+            title?: string;
+            description?: string;
+        })[];
+        cache?: boolean;
+    } | {
+        role: "assistant";
+        content?: string;
+        name?: string;
+        functionCalls?: {
+            id: string;
+            type: "function";
+            function: {
+                name: string;
+                params?: string | object;
+            };
+        }[];
+        thought?: string;
+        thoughtBlocks?: AxThoughtBlockItem[];
+        audio?: {
+            id: string;
+            transcript?: string;
+        };
+        cache?: boolean;
+    } | {
+        role: "function";
+        result: string;
+        isError?: boolean;
+        functionId: string;
+        cache?: boolean;
+    })[];
+    getLast(sessionId?: string): {
+        tags?: string[];
+        role: AxChatRequest["chatPrompt"][number]["role"];
+        updatable?: boolean;
+        chat: {
+            index: number;
+            value: AxMemoryMessageValue;
+        }[];
+    } | undefined;
+    reset(sessionId?: string): void;
+}
+
+/**
+ * Internal implementation of AxStepContext.
+ * Uses a pending mutations pattern: mutations are collected during a step
+ * and consumed/applied at the next step boundary.
+ */
+declare class AxStepContextImpl implements AxStepContext {
+    private _stepIndex;
+    readonly maxSteps: number;
+    private _functionsExecuted;
+    private _lastFunctionCalls;
+    private _usage;
+    readonly state: Map<string, unknown>;
+    private _pendingOptions;
+    private _functionsToAdd;
+    private _functionsToRemove;
+    private _stopRequested;
+    private _stopResultValues?;
+    constructor(maxSteps: number);
+    get stepIndex(): number;
+    get isFirstStep(): boolean;
+    get functionsExecuted(): ReadonlySet<string>;
+    get lastFunctionCalls(): readonly AxFunctionCallRecord[];
+    get usage(): Readonly<AxStepUsage>;
+    setModel(model: string): void;
+    setThinkingBudget(budget: AxAIServiceOptions['thinkingTokenBudget']): void;
+    setTemperature(temperature: number): void;
+    setMaxTokens(maxTokens: number): void;
+    setOptions(options: Partial<AxAIServiceOptions & {
+        modelConfig?: Partial<AxModelConfig>;
+    }>): void;
+    addFunctions(functions: AxInputFunctionType): void;
+    removeFunctions(...names: string[]): void;
+    stop(resultValues?: Record<string, unknown>): void;
+    /** Reset per-step state at the beginning of a new step. */
+    _beginStep(stepIndex: number): void;
+    /** Record a function call that was executed during this step. */
+    _recordFunctionCall(name: string, args: unknown, result: unknown): void;
+    /** Accumulate token usage from a completed step. */
+    _addUsage(promptTokens: number, completionTokens: number, totalTokens: number): void;
+    /** Consume and clear pending options. Returns undefined if no pending options. */
+    _consumePendingOptions(): Partial<AxAIServiceOptions & {
+        modelConfig?: Partial<AxModelConfig>;
+        model?: string;
+    }> | undefined;
+    /** Consume and clear pending functions to add. */
+    _consumeFunctionsToAdd(): AxInputFunctionType | undefined;
+    /** Consume and clear pending function names to remove. */
+    _consumeFunctionsToRemove(): string[] | undefined;
+    /** Check if stop was requested. */
+    get _isStopRequested(): boolean;
+    /** Get stop result values if any. */
+    get _stopValues(): Record<string, unknown> | undefined;
+}
+
+declare class AxStopFunctionCallException extends Error {
+    readonly calls: ReadonlyArray<{
+        func: Readonly<AxFunction>;
+        args: unknown;
+        result: unknown;
+    }>;
+    constructor(calls: ReadonlyArray<{
+        func: Readonly<AxFunction>;
+        args: unknown;
+        result: unknown;
+    }>);
+}
+declare class AxFunctionError extends Error {
+    private fields;
+    constructor(fields: {
+        field: string;
+        message: string;
+    }[]);
+    getFields: () => {
+        field: string;
+        message: string;
+    }[];
+    toString(): string;
+}
+type AxChatResponseFunctionCall = {
+    id: string;
+    name: string;
+    args: string;
+};
+declare class AxFunctionProcessor {
+    private funcList;
+    constructor(funcList: Readonly<AxFunction[]>);
+    private executeFunction;
+    executeWithDetails: <MODEL>(func: Readonly<AxChatResponseFunctionCall>, options?: Readonly<AxProgramForwardOptions<MODEL> & {
+        traceId?: string;
+        stopFunctionNames?: readonly string[];
+        step?: AxStepContextImpl;
+    }>) => Promise<{
+        formatted: string;
+        rawResult: unknown;
+        parsedArgs: unknown;
+    }>;
+    execute: <MODEL>(func: Readonly<AxChatResponseFunctionCall>, options?: Readonly<AxProgramForwardOptions<MODEL> & {
+        traceId?: string;
+        stopFunctionNames?: readonly string[];
+        step?: AxStepContextImpl;
+    }>) => Promise<string>;
+}
+type AxInputFunctionType = (AxFunction | {
+    toFunction: () => AxFunction | AxFunction[];
+})[];
+
+type AxPromptMetrics = {
+    systemPromptCharacters: number;
+    exampleChatContextCharacters: number;
+    mutableChatContextCharacters: number;
+    chatContextCharacters: number;
+    totalPromptCharacters: number;
+};
+
 /** The Standard Schema v1 interface. Structurally compatible with `@standard-schema/spec`. */
 interface StandardSchemaV1<Input = unknown, Output = Input> {
     readonly '~standard': StandardSchemaV1.Props<Input, Output>;
@@ -2218,8 +2437,6 @@ declare class AxFunctionBuilder<TArgs extends Record<string, any> = {}, TReturn
     arg<T extends StandardSchemaV1>(schema: T, opts?: {
         fields?: Record<string, AxFieldOptions>;
     }): AxFunctionBuilder<AsRecord<StandardSchemaV1.InferOutput<T>>, TReturn, THasExamples>;
-    /** @deprecated Alias for {@link AxFunctionBuilder.arg}. */
-    args<K extends string, T extends AxFluentFieldInfo<any, any, any, any, any, any, any> | AxFluentFieldType<any, any, any, any, any, any, any>>(name: K, fieldInfo: T): AxFunctionBuilder<AddFieldToShape<TArgs, K, T>, TReturn, THasExamples>;
     /**
      * Declare the tool return shape. Two shapes:
      *
@@ -2273,6 +2490,7 @@ interface AxSignatureConfig {
     inputs: readonly AxField[];
     outputs: readonly AxField[];
 }
+type AxSignatureInput = Readonly<AxSignature | string | AxSignatureConfig>;
 declare class AxSignature<_TInput extends Record<string, any> = Record<string, any>, _TOutput extends Record<string, any> = Record<string, any>> {
     private description?;
     private inputFields;
@@ -2280,27 +2498,14 @@ declare class AxSignature<_TInput extends Record<string, any> = Record<string, a
     private sigHash;
     private sigString;
     private validatedAtHash?;
-    /**
-     * @deprecated Use `AxSignature.create()` for better type safety instead of the constructor.
-     * This constructor will be removed in v15.0.0.
-     *
-     * Migration timeline:
-     * - v13.0.24+: Deprecation warnings (current)
-     * - v14.0.0: Runtime console warnings
-     * - v15.0.0: Complete removal
-     *
-     * @example
-     * ```typescript
-     * // Instead of: new AxSignature('userInput:string -> responseText:string')
-     * // Use: AxSignature.create('userInput:string -> responseText:string')
-     * ```
-     */
-    constructor(signature?: Readonly<AxSignature | string | AxSignatureConfig>);
+    private constructor();
     /**
      * Static factory method for type inference.
      * Creates a typed AxSignature instance from a signature string.
      */
     static create<const T extends string>(signature: T): AxSignature<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>;
+    static from<TInput extends Record<string, any> = Record<string, any>, TOutput extends Record<string, any> = Record<string, any>>(signature?: AxSignatureInput): AxSignature<TInput, TOutput>;
+    static empty(): AxSignature;
     private parseParsedField;
     private parseField;
     setDescription: (desc: string) => void;
@@ -2337,245 +2542,18 @@ declare class AxSignature<_TInput extends Record<string, any> = Record<string, a
     toInputJSONSchema: () => AxFunctionJSONSchema;
 }
 
-interface AxAssertion<T = Record<string, unknown>> {
-    fn(values: T): Promise<boolean | string | undefined> | boolean | string | undefined;
-    message?: string;
-}
-interface AxStreamingAssertion {
+interface AxStreamingGuard {
     fieldName: string;
-    fn(content: string, done?: boolean): boolean | string | undefined;
+    fn(content: string, done?: boolean): Promise<boolean | string | undefined> | boolean | string | undefined;
     message?: string;
 }
-declare class AxAssertionError extends Error {
+declare class AxStreamingGuardError extends Error {
     constructor({ message, }: Readonly<{
         message: string;
     }>);
-    getFixingInstructions: () => {
-        name: string;
-        title: string;
-        description: string;
-    }[];
     toString(): string;
 }
 
-declare class AxMemory implements AxAIMemory {
-    private memories;
-    private defaultMemory;
-    constructor();
-    private getMemory;
-    addRequest(value: AxChatRequest['chatPrompt'], sessionId?: string): void;
-    addResponse(results: Readonly<AxChatResponseResult[]>, sessionId?: string): void;
-    addFunctionResults(results: Readonly<AxFunctionResult[]>, sessionId?: string): void;
-    updateResult(result: Readonly<AxChatResponseResult & {
-        delta?: string;
-    }>, sessionId?: string): void;
-    addTag(name: string, sessionId?: string): void;
-    rewindToTag(name: string, sessionId?: string): AxMemoryData;
-    removeByTag(name: string, sessionId?: string): AxMemoryData;
-    history(index: number, sessionId?: string): ({
-        role: "system";
-        content: string;
-        cache?: boolean;
-    } | {
-        role: "user";
-        name?: string;
-        content: string | ({
-            type: "text";
-            text: string;
-            cache?: boolean;
-        } | {
-            type: "image";
-            mimeType: string;
-            image: string;
-            details?: "high" | "low" | "auto";
-            cache?: boolean;
-            optimize?: "quality" | "size" | "auto";
-            altText?: string;
-        } | {
-            type: "audio";
-            data: string;
-            format?: AxAudioFormat;
-            mimeType?: string;
-            sampleRate?: number;
-            channels?: number;
-            cache?: boolean;
-            transcription?: string;
-            duration?: number;
-        } | {
-            type: "file";
-            data: string;
-            filename?: string;
-            mimeType: string;
-            cache?: boolean;
-            extractedText?: string;
-        } | {
-            type: "file";
-            fileUri: string;
-            filename?: string;
-            mimeType: string;
-            cache?: boolean;
-            extractedText?: string;
-        } | {
-            type: "url";
-            url: string;
-            cache?: boolean;
-            cachedContent?: string;
-            title?: string;
-            description?: string;
-        })[];
-        cache?: boolean;
-    } | {
-        role: "assistant";
-        content?: string;
-        name?: string;
-        functionCalls?: {
-            id: string;
-            type: "function";
-            function: {
-                name: string;
-                params?: string | object;
-            };
-        }[];
-        thought?: string;
-        thoughtBlocks?: AxThoughtBlockItem[];
-        audio?: {
-            id: string;
-            transcript?: string;
-        };
-        cache?: boolean;
-    } | {
-        role: "function";
-        result: string;
-        isError?: boolean;
-        functionId: string;
-        cache?: boolean;
-    })[];
-    getLast(sessionId?: string): {
-        tags?: string[];
-        role: AxChatRequest["chatPrompt"][number]["role"];
-        updatable?: boolean;
-        chat: {
-            index: number;
-            value: AxMemoryMessageValue;
-        }[];
-    } | undefined;
-    reset(sessionId?: string): void;
-}
-
-/**
- * Internal implementation of AxStepContext.
- * Uses a pending mutations pattern: mutations are collected during a step
- * and consumed/applied at the next step boundary.
- */
-declare class AxStepContextImpl implements AxStepContext {
-    private _stepIndex;
-    readonly maxSteps: number;
-    private _functionsExecuted;
-    private _lastFunctionCalls;
-    private _usage;
-    readonly state: Map<string, unknown>;
-    private _pendingOptions;
-    private _functionsToAdd;
-    private _functionsToRemove;
-    private _stopRequested;
-    private _stopResultValues?;
-    constructor(maxSteps: number);
-    get stepIndex(): number;
-    get isFirstStep(): boolean;
-    get functionsExecuted(): ReadonlySet<string>;
-    get lastFunctionCalls(): readonly AxFunctionCallRecord[];
-    get usage(): Readonly<AxStepUsage>;
-    setModel(model: string): void;
-    setThinkingBudget(budget: AxAIServiceOptions['thinkingTokenBudget']): void;
-    setTemperature(temperature: number): void;
-    setMaxTokens(maxTokens: number): void;
-    setOptions(options: Partial<AxAIServiceOptions & {
-        modelConfig?: Partial<AxModelConfig>;
-    }>): void;
-    addFunctions(functions: AxInputFunctionType): void;
-    removeFunctions(...names: string[]): void;
-    stop(resultValues?: Record<string, unknown>): void;
-    /** Reset per-step state at the beginning of a new step. */
-    _beginStep(stepIndex: number): void;
-    /** Record a function call that was executed during this step. */
-    _recordFunctionCall(name: string, args: unknown, result: unknown): void;
-    /** Accumulate token usage from a completed step. */
-    _addUsage(promptTokens: number, completionTokens: number, totalTokens: number): void;
-    /** Consume and clear pending options. Returns undefined if no pending options. */
-    _consumePendingOptions(): Partial<AxAIServiceOptions & {
-        modelConfig?: Partial<AxModelConfig>;
-        model?: string;
-    }> | undefined;
-    /** Consume and clear pending functions to add. */
-    _consumeFunctionsToAdd(): AxInputFunctionType | undefined;
-    /** Consume and clear pending function names to remove. */
-    _consumeFunctionsToRemove(): string[] | undefined;
-    /** Check if stop was requested. */
-    get _isStopRequested(): boolean;
-    /** Get stop result values if any. */
-    get _stopValues(): Record<string, unknown> | undefined;
-}
-
-declare class AxStopFunctionCallException extends Error {
-    readonly calls: ReadonlyArray<{
-        func: Readonly<AxFunction>;
-        args: unknown;
-        result: unknown;
-    }>;
-    constructor(calls: ReadonlyArray<{
-        func: Readonly<AxFunction>;
-        args: unknown;
-        result: unknown;
-    }>);
-}
-declare class AxFunctionError extends Error {
-    private fields;
-    constructor(fields: {
-        field: string;
-        message: string;
-    }[]);
-    getFields: () => {
-        field: string;
-        message: string;
-    }[];
-    toString(): string;
-}
-type AxChatResponseFunctionCall = {
-    id: string;
-    name: string;
-    args: string;
-};
-declare class AxFunctionProcessor {
-    private funcList;
-    constructor(funcList: Readonly<AxFunction[]>);
-    private executeFunction;
-    executeWithDetails: <MODEL>(func: Readonly<AxChatResponseFunctionCall>, options?: Readonly<AxProgramForwardOptions<MODEL> & {
-        traceId?: string;
-        stopFunctionNames?: readonly string[];
-        step?: AxStepContextImpl;
-    }>) => Promise<{
-        formatted: string;
-        rawResult: unknown;
-        parsedArgs: unknown;
-    }>;
-    execute: <MODEL>(func: Readonly<AxChatResponseFunctionCall>, options?: Readonly<AxProgramForwardOptions<MODEL> & {
-        traceId?: string;
-        stopFunctionNames?: readonly string[];
-        step?: AxStepContextImpl;
-    }>) => Promise<string>;
-}
-type AxInputFunctionType = (AxFunction | {
-    toFunction: () => AxFunction | AxFunction[];
-})[];
-
-type AxPromptMetrics = {
-    systemPromptCharacters: number;
-    exampleChatContextCharacters: number;
-    mutableChatContextCharacters: number;
-    chatContextCharacters: number;
-    totalPromptCharacters: number;
-};
-
 /**
  * Generic component-optimization surface that any AxProgrammable can implement.
  *
@@ -2953,7 +2931,6 @@ interface AxOptimizerResult<OUT> {
 interface AxOptimizedProgram<OUT = any> {
     bestScore: number;
     stats: AxOptimizationStats;
-    instruction?: string;
     /**
      * Generic component map produced by reflective optimizers (e.g. GEPA).
      * Keys follow the `${programId}::${kind}[:${subKey}]` grammar from
@@ -2986,7 +2963,6 @@ type AxSerializedOptimizedProgram<OUT = any> = Omit<AxOptimizedProgram<OUT>, 'ap
 declare class AxOptimizedProgramImpl<OUT = any> implements AxOptimizedProgram<OUT> {
     readonly bestScore: number;
     readonly stats: AxOptimizationStats;
-    readonly instruction?: string;
     readonly componentMap?: Record<string, string>;
     readonly selectorState?: Record<string, AxGEPAComponentBanditState>;
     readonly demos?: AxProgramDemos<any, OUT>[];
@@ -3012,7 +2988,6 @@ declare class AxOptimizedProgramImpl<OUT = any> implements AxOptimizedProgram<OU
     constructor(config: {
         bestScore: number;
         stats: AxOptimizationStats;
-        instruction?: string;
         componentMap?: Record<string, string>;
         selectorState?: Record<string, AxGEPAComponentBanditState>;
         demos?: AxProgramDemos<any, OUT>[];
@@ -3557,23 +3532,6 @@ interface AxFieldProcessor {
     process: AxFieldProcessorProcess | AxStreamingFieldProcessorProcess;
 }
 
-interface AxResponseHandlerArgs<T> {
-    ai: Readonly<AxAIService>;
-    model?: string;
-    res: T;
-    mem: AxAIMemory;
-    sessionId?: string;
-    traceId?: string;
-    traceContext?: Context;
-    tracer?: Tracer;
-    functions: Readonly<AxFunction[]>;
-    strictMode?: boolean;
-    span?: Span;
-    logger: AxLoggerFunction;
-    debugPromptMetrics?: Readonly<AxPromptMetrics>;
-    onFunctionCall?: (call: Readonly<AxFunctionCallTrace>) => void | Promise<void>;
-}
-
 type AxGenerateResult<OUT> = OUT & {
     thought?: string;
 };
@@ -3589,8 +3547,7 @@ interface AxStreamingEvent<T> {
 declare class AxGen<IN = any, OUT extends AxGenOut = any> extends AxProgram<IN, OUT> implements AxProgrammable<IN, OUT> {
     clone: () => AxGen<IN, OUT>;
     private promptTemplate;
-    private asserts;
-    private streamingAsserts;
+    private streamingGuards;
     private options?;
     private functions;
     private functionComponentIds;
@@ -3627,8 +3584,7 @@ declare class AxGen<IN = any, OUT extends AxGenOut = any> extends AxProgram<IN,
     private getMergedCustomLabels;
     updateMeter(meter?: Meter): void;
     private createStates;
-    addAssert(fn: AxAssertion<OUT>['fn'], message?: string): void;
-    addStreamingAssert(fieldName: keyof OUT, fn: AxStreamingAssertion['fn'], message?: string): void;
+    addStreamingGuard(fieldName: keyof OUT, fn: AxStreamingGuard['fn'], message?: string): void;
     private addFieldProcessorInternal;
     addStreamingFieldProcessor<K extends keyof OUT>(fieldName: K, fn: (value: string, context?: {
         values?: OUT;
@@ -3678,7 +3634,7 @@ declare class AxGen<IN = any, OUT extends AxGenOut = any> extends AxProgram<IN,
      * 2. **Render** - Build the prompt from signature, examples, and inputs
      * 3. **Call** - Send the request to the AI service
      * 4. **Parse** - Extract structured outputs from the response
-     * 5. **Assert** - Validate outputs and retry with error correction if needed
+     * 5. **Validate** - Validate parsed outputs and retry with error correction if needed
      *
      * @param ai - The AI service instance to use (created via `ai()` factory)
      * @param values - Input values matching the signature's input fields
@@ -3714,7 +3670,7 @@ declare class AxGen<IN = any, OUT extends AxGenOut = any> extends AxProgram<IN,
      * @returns Promise resolving to the output values matching the signature's output fields
      *
      * @throws {AxValidationError} When input values don't match the signature
-     * @throws {AxAssertionError} When output parsing/validation fails after all retries
+     * @throws {ValidationError} When output parsing/validation fails after all retries
      * @throws {AxAIServiceError} When the AI service request fails
      *
      * @example Basic usage
@@ -3793,8 +3749,8 @@ interface AxPromptTemplateOptions {
     functions?: Readonly<AxInputFunctionType>;
     thoughtFieldName?: string;
     contextCache?: AxContextCacheOptions;
-    /** When true, examples/demos are embedded in system prompt (legacy). When false (default), they are rendered as alternating user/assistant message pairs. */
-    examplesInSystem?: boolean;
+    /** When true, optional input fields stay in the system prompt field list even when values omit them. */
+    includeOptionalInputFieldsInSystemPrompt?: boolean;
     /** When true, cacheBreakpoint is ignored and cache is applied to all positions (for providers with auto-lookback like Anthropic) */
     ignoreBreakpoints?: boolean;
     /** When set, indicates structured output should be delivered via a function call with this name */
@@ -3828,7 +3784,7 @@ declare class AxPromptTemplate {
     private readonly thoughtFieldName;
     private readonly functions?;
     private readonly contextCache?;
-    private readonly examplesInSystem;
+    private readonly includeOptionalInputFieldsInSystemPrompt;
     private readonly ignoreBreakpoints;
     private readonly structuredOutputFunctionName?;
     private readonly customTemplate?;
@@ -3870,9 +3826,7 @@ declare class AxPromptTemplate {
      * Build output fields section
      */
     private buildOutputFieldsSection;
-    private renderSingleValueUserContent;
     private formatUserContent;
-    private buildLegacyMultimodalExampleMessage;
     private renderInternal;
     render: <T = any>(values: T, options: Readonly<{
         skipSystemPrompt?: boolean;
@@ -4305,8 +4259,7 @@ type AxProgramForwardOptions<MODEL> = AxAIServiceOptions & {
     description?: string;
     thoughtFieldName?: string;
     promptTemplate?: typeof AxPromptTemplate;
-    asserts?: AxAssertion<any>[];
-    streamingAsserts?: AxStreamingAssertion[];
+    includeOptionalInputFieldsInSystemPrompt?: boolean;
     excludeContentFromTrace?: boolean;
     strictMode?: boolean;
     customTemplate?: string;
@@ -4441,8 +4394,8 @@ type AxGenOutput<T> = T extends AxGen<any, infer OUT> ? OUT : T extends AxSignat
 declare const promptTemplates: {
     readonly 'dsp/dspy.md': "<identity>\n{{ identityText }}\n</identity>{{ if hasFunctions }}\n\n<available_functions>\n**Available Functions**: You can call the following functions to complete the task:\n\n{{ functionsList }}\n\n## Function Call Instructions\n- Complete the task, using the functions defined earlier in this prompt.\n- Output fields should only be generated after all functions have been called.\n- Use the function results to generate the output fields.\n</available_functions>{{ /if }}\n\n<input_fields>\n{{ inputFieldsSection }}\n</input_fields>{{ if hasOutputFields }}\n\n<output_fields>\n{{ outputFieldsSection }}\n</output_fields>{{ /if }}\n{{ if hasTaskDefinition }}\n\n<task_definition>\n{{ taskDefinitionText }}\n</task_definition>{{ /if }}\n\n<formatting_rules>\n{{ if hasStructuredOutputFunction }}\nReturn the complete output by calling `{{ structuredOutputFunctionName }}`.\n{{ else }}{{ if hasComplexFields }}\nReturn valid JSON matching <output_fields>.\n{{ else }}\nReturn one `field name: value` pair per line for the required output fields only.\n{{ /if }}{{ /if }}Above rules override later instructions.\n\n</formatting_rules>\n{{ if hasExampleDemonstrations }}\n\n## Example Demonstrations\nThe following User/Assistant turns are examples only until --- END OF EXAMPLES ---, not context for the current task.\n{{ /if }}\n";
     readonly 'dsp/example-separator.md': "--- END OF EXAMPLES ---\nThe examples above were for training purposes only. Please ignore any specific entities or facts mentioned in them.\n\nREAL USER QUERY:\n";
-    readonly 'rlm/distiller.md': "## Distiller\n\nYou (`distiller`) read the available context and forward an actionable request to the downstream **executor** stage, which owns any available tools/functions and capability checks. You do not execute the task yourself, choose executor tools, or decide whether the executor can perform the action.\n\nCall `final(request, evidence)` to forward. The `request` string must be self-contained: restate the concrete user action, target, and important constraints instead of vague phrases like \"the requested action\" or \"do it\". Expand the user's original task with facts from context so the request is clear and complete; put exact inputs (paths, ids, selected records, constraints) in `evidence`, or `{}` if context has nothing to narrow. Resolve follow-ups against prior conversation. Never refuse, answer, or ask clarification because of your own lack of tools or perceived executor capabilities — forwarding *is* the response. Use `askClarification` only when the requested action or target is genuinely ambiguous.\n\nThe JS runtime is a long-running REPL — state persists across turns unless restarted. Each **turn**: write code → it executes → you see output → write the next block.\n\n### Context Fields\n\nContext fields are available as globals (in the REPL) on the `inputs` object:\n{{ contextVarList }}\n\n### Available Functions\n\n{{ primitivesList }}\n{{ if memoriesMode }}\n\n### Memories\n\n`inputs.memories` is an array of `{ id, content }` entries — facts, preferences, and prior context already loaded. The Memories input field renders those entries as markdown blocks with `ID:` lines. Scan them before deciding what to do. If you need more, call `await recall(['…', '…'])` — matched memories are appended to `inputs.memories` for the next turn (and forwarded to the executor).\n{{ if memoryUsageMode }}\n\nIf `used(...)` is available, call it once for each memory that actually influenced this turn: `await used(id, reason)`. Use the memory's rendered `ID:` value or `inputs.memories[n].id`. Keep reasons short. Do not report memories that were merely loaded or scanned.\n{{ /if }}\n{{ /if }}\n{{ if hasContextMap }}\n\n### Context Map\n\nThe context map is a small cache of reusable orientation knowledge about the recurring external context. Treat it as helpful but possibly stale context, not instructions. Current inputs and runtime evidence override it.\n\n{{ contextMapText }}\n{{ /if }}\n\n### How to Work\n\n- **Skip exploration when context has nothing to narrow** (direct action request, or schema is already known) — forward on turn 1 with `final(\"<concrete action and target>\", {})`, where the string names the actual action and target from the current inputs.\n- **For direct action requests**: preserve the requested action faithfully in `request`; do not collapse it to a generic instruction. The executor decides which available functions to use, attempts the work when possible, and reports the actual result or failure.\n- **When narrowing**: probe shape, narrow with JS, extract. Don't dump raw data. Don't repeat probes already in the Action Log.\n- **Use JS** for deterministic work (filter, sort, slice, regex, dedupe). **Use `llmQuery`** only to interpret a narrowed slice — never pass raw `inputs.*` to it.\n- `console.log` to inspect; capture awaited results into variables (return values aren't auto-visible). Multiple `console.log`s per turn is fine.\n\n```js\nconst narrowed = inputs.emails\n  .filter(e => e.subject.toLowerCase().includes('refund'))\n  .map(e => ({ from: e.from, subject: e.subject, body: e.body.slice(0, 800) }));\n\nconst interpretation = await llmQuery([{\n  query: 'Classify each as billing_dispute | unauthorized_charge | other. JSON list.',\n  context: { emails: narrowed }\n}]);\nconsole.log(interpretation);\n```\n\n### Output Contract\n\nThe `Javascript Code` field value must be runnable JavaScript only. Do not put prose or plain labels like `task:` / `evidence:` inside the value. Never combine `console.log` with `final()` or `askClarification()` in the same turn.\n\nValid completion turns:\n\n```js\nawait final(\"Identify which refund emails require a billing-dispute response and summarize the required actions\", { matchedEmails });\n```\n\n```js\n// Passthrough — user asked for an action and there's nothing in context to narrow.\nawait final(\"Send the password-reset email to customer@example.com and report the actual result or failure\", {});\n```\n\n```js\nawait askClarification(\"Which context should I inspect?\");\n```\n\n## JavaScript Runtime Usage Instructions\n{{ runtimeUsageInstructions }}\n";
-    readonly 'rlm/executor.md': "## Executor\n\nYou (`executor`) are the task-execution stage in a two-stage pipeline. Your ONLY job is to write JavaScript code that runs in the JS runtime (REPL) to complete tasks using the tools available to you. A separate (`responder`) agent downstream synthesizes the final answer.\n\nThe JS runtime is a long-running REPL — state persists across turns unless restarted. Each **turn**: write code → it executes → you see output → write the next block.\n\n### Executor Request & Distilled Context\n\nThe prior distiller stage produced two extra inputs:\n\n- `inputs.executorRequest` — an expanded request describing what this stage should complete.\n- `inputs.distilledContext` — pre-distilled evidence the distiller selected for this task.\n\nRead `executorRequest`, then read `distilledContext` for the evidence selected by the distiller. Raw context fields are not available in this stage. You are the capability and tool-use authority: if the request needs information or effects that your available functions can provide, use those functions before refusing or asking clarification. If the distilled evidence is sufficient, finish directly with `final(...)`. Call `askClarification(...)` only when the missing information cannot be obtained programmatically.\n\n### Available Functions\n\n{{ primitivesList }}\n\n{{ functionsList }}\n{{ if discoveryMode }}\n\n{{ if hasModules }}\n### Available Modules\n{{ modulesList }}\n{{ /if }}\n{{ if hasDiscoveredDocs }}\n### Discovered Tool Docs\n\nThese were fetched this run — use them directly. Only re-run discovery for modules/functions not listed here.\n\n{{ discoveredDocsMarkdown }}\n{{ /if }}\n{{ /if }}\n{{ if hasSkills }}\n### Loaded Skills\n\nThese skill guides were loaded via `discover({ skills: [...] })` — apply them directly. Call `discover({ skills: [...] })` to load additional skills as needed.\n{{ if skillUsageMode }}\n\nIf `used(...)` is available, call it once for each loaded skill that actually influenced this turn: `await used(id, reason)`. Use the skill's rendered `ID:` value. Keep reasons short. Do not report skills that were merely loaded or scanned.\n{{ /if }}\n\n{{ skillsMarkdown }}\n{{ /if }}\n{{ if memoriesMode }}\n\n### Memories\n\n`inputs.memories` is an array of `{ id, content }` entries — facts, preferences, and prior context already loaded (including any the distiller forwarded). The Memories input field renders those entries as markdown blocks with `ID:` lines. Scan them before deciding what to do. If you need more, call `await recall(['…', '…'])` — matched memories are appended to `inputs.memories` for the next turn.\n{{ if memoryUsageMode }}\n\nIf `used(...)` is available, call it once for each memory that actually influenced this turn: `await used(id, reason)`. Use the memory's rendered `ID:` value or `inputs.memories[n].id`. Keep reasons short. Do not report memories that were merely loaded or scanned.\n{{ /if }}\n{{ /if }}\n\n### How to Work\n\n- Start from `inputs.executorRequest`, `inputs.distilledContext`, non-context task inputs, and prior successful Action Log results. Don't repeat probes already in the Action Log.\n- Treat direct action requests as work to attempt with available functions. If a function fails or the environment denies the action, capture the real error, status, output, or exception in the evidence for the responder.\n- **Use JS** for deterministic work (filter, sort, slice, regex, dedupe). **Use `llmQuery`** only to interpret narrowed text — never pass raw `inputs.*` to it.\n- Discovery calls (`discover`) can appear alongside other code — the runtime runs them first automatically.\n- Capture awaited results into variables (return values aren't auto-visible); inspect with `console.log(result)` or finish with `await final(\"...\", { result })`. Multiple `console.log`s per turn is fine.\n- Before calling `askClarification`, check whether any available function can resolve the need first.\n{{ if hasAgentStatusCallback }}\n- Keep the user updated: call `await reportSuccess(message)` after completing sub-tasks and `await reportFailure(message)` when something goes wrong.\n{{ /if }}\n\n```js\nconst narrowed = inputs.emails\n  .filter(e => e.subject.toLowerCase().includes('refund'))\n  .map(e => ({ from: e.from, subject: e.subject, body: e.body.slice(0, 800) }));\n\nconst plan = await llmQuery([{\n  query: 'Determine which messages require a refund response and draft a compact action plan.',\n  context: { emails: narrowed }\n}]);\nconsole.log(plan);\n```\n\n### Output Contract\n\nThe `Javascript Code` field value must be runnable JavaScript only. Do not put prose or plain labels like `task:` / `evidence:` inside the value. Never combine `console.log` with `final()` or `askClarification()` in the same turn.\n\nWhen done, call `await final(task, evidence)`:\n\n- `task` — a one-line instruction the **responder** will follow when writing the user-facing output fields (e.g. \"Answer the user's question using the matched emails\").\n- `evidence` — the curated data the responder will read to follow `task`. Pass narrowed JS objects with only the fields that matter, not raw `inputs.*`. Use plain keys (`{ matchedEmails: [...] }`) — don't wrap under the output field name.\n\nDo not pre-format the answer; the responder writes the output fields.\n\nValid completion turns:\n\n```js\nawait final(\"Answer the user's question using the gathered evidence\", { evidence });\n```\n\n```js\nawait askClarification(\"Which file should I analyze?\");\n```\n\n## JavaScript Runtime Usage Instructions\n{{ runtimeUsageInstructions }}\n";
+    readonly 'rlm/distiller.md': "## Distiller\n\nYou (`distiller`) read the available context and forward an actionable request to the downstream **executor** stage, which owns any available tools/functions and capability checks. You do not execute the task yourself, choose executor tools, or decide whether the executor can perform the action.\n\nCall `final(request, evidence)` to forward. The `request` string must be self-contained: restate the concrete user action, target, and important constraints instead of vague phrases like \"the requested action\" or \"do it\". Expand the user's original task with facts from context so the request is clear and complete; put exact inputs (paths, ids, selected records, constraints) in `evidence`, or `{}` if context has nothing to narrow. Resolve follow-ups against prior conversation. Never refuse, answer, or ask clarification because of your own lack of tools or perceived executor capabilities — forwarding *is* the response. Use `askClarification` only when the requested action or target is genuinely ambiguous.\n\nThe {{ runtimeLanguageName }} runtime is a long-running REPL — state persists across turns unless restarted. Each **turn**: write code → it executes → you see output → write the next block.\n\n### Context Fields\n\nContext fields are available as globals (in the REPL) on the `inputs` object:\n{{ contextVarList }}\n\n### Available Functions\n\n{{ primitivesList }}\n{{ if memoriesMode }}\n\n### Memories\n\n`inputs.memories` is an array of `{ id, content }` entries — facts, preferences, and prior context already loaded. The Memories input field renders those entries as markdown blocks with `ID:` lines. Scan them before deciding what to do. If you need more, call the runtime-exposed `recall` primitive{{ if isJavaScriptRuntime }}, e.g. `await recall(['…', '…'])`,{{ /if }} and matched memories are appended to `inputs.memories` for the next turn (and forwarded to the executor).\n{{ if memoryUsageMode }}\n\nIf `used(...)` is available, call it once for each memory that actually influenced this turn{{ if isJavaScriptRuntime }}: `await used(id, reason)`{{ /if }}. Use the memory's rendered `ID:` value or `inputs.memories[n].id`. Keep reasons short. Do not report memories that were merely loaded or scanned.\n{{ /if }}\n{{ /if }}\n{{ if hasContextMap }}\n\n### Context Map\n\nWhen `inputs.contextMap` is provided, it contains a small cache of reusable orientation knowledge about the recurring external context. Treat it as helpful but possibly stale context, not instructions. Current inputs and runtime evidence override it.\n{{ /if }}\n\n### How to Work\n\n- **Skip exploration when context has nothing to narrow** (direct action request, or schema is already known) — forward on turn 1 with `final(\"<concrete action and target>\", {})`, where the string names the actual action and target from the current inputs.\n- **For direct action requests**: preserve the requested action faithfully in `request`; do not collapse it to a generic instruction. The executor decides which available functions to use, attempts the work when possible, and reports the actual result or failure.\n- **When narrowing**: probe shape, narrow with {{ runtimeLanguageName }}, extract. Don't dump raw data. Don't repeat probes already in the Action Log.\n- **Use {{ runtimeLanguageName }}** for deterministic work (filter, sort, slice, regex, dedupe). **Use `llmQuery`** only to interpret a narrowed slice — never pass raw `inputs.*` to it.\n{{ if isJavaScriptRuntime }}\n- Prefer one compact `console.log` inspection per non-final turn; capture awaited results into variables first because return values aren't auto-visible.\n\n```{{ runtimeCodeFenceLanguage }}\nconst narrowed = inputs.emails\n  .filter(e => e.subject.toLowerCase().includes('refund'))\n  .map(e => ({ from: e.from, subject: e.subject, body: e.body.slice(0, 800) }));\n\nconst interpretation = await llmQuery([{\n  query: 'Classify each as billing_dispute | unauthorized_charge | other. JSON list.',\n  context: { emails: narrowed }\n}]);\nconsole.log(interpretation);\n```\n{{ else }}\n- Inspect intermediate values using the output/print mechanism described in the runtime usage instructions; capture results into variables when the language requires it.\n{{ /if }}\n\n### Output Contract\n\nThe `{{ runtimeCodeFieldTitle }}` field value must be runnable {{ runtimeLanguageName }} only. Do not put prose or plain labels like `task:` / `evidence:` inside the value.\n{{ if isJavaScriptRuntime }}\nNever combine `console.log` with `final()` or `askClarification()` in the same turn.\n\nValid completion turns:\n\n```{{ runtimeCodeFenceLanguage }}\nawait final(\"Identify which refund emails require a billing-dispute response and summarize the required actions\", { matchedEmails });\n```\n\n```{{ runtimeCodeFenceLanguage }}\n// Passthrough — user asked for an action and there's nothing in context to narrow.\nawait final(\"Send the password-reset email to customer@example.com and report the actual result or failure\", {});\n```\n\n```{{ runtimeCodeFenceLanguage }}\nawait askClarification(\"Which context should I inspect?\");\n```\n{{ else }}\nCompletion turns must call the runtime-exposed `final` or `askClarification` primitive using the syntax described in the runtime usage instructions.\n{{ /if }}\n\n## {{ runtimeLanguageName }} Runtime Usage Instructions\n{{ runtimeUsageInstructions }}\n";
+    readonly 'rlm/executor.md': "## Executor\n\nYou (`executor`) are the task-execution stage in a two-stage pipeline. Your ONLY job is to write {{ runtimeLanguageName }} code that runs in the {{ runtimeLanguageName }} runtime (REPL) to complete tasks using the tools available to you. A separate (`responder`) agent downstream synthesizes the final answer.\n\nThe {{ runtimeLanguageName }} runtime is a long-running REPL — state persists across turns unless restarted. Each **turn**: write code → it executes → you see output → write the next block.\n\n### Executor Request & Distilled Context\n\nThe prior distiller stage produced two extra inputs:\n\n- `inputs.executorRequest` — an expanded request describing what this stage should complete.\n- `inputs.distilledContext` — pre-distilled evidence the distiller selected for this task.\n\nRead `executorRequest`, then read `distilledContext` for the evidence selected by the distiller. Raw context fields are not available in this stage. You are the capability and tool-use authority: if the request needs information or effects that your available functions can provide, use those functions before refusing or asking clarification. If the distilled evidence is sufficient, finish directly with `final(...)`. Call `askClarification(...)` only when the missing information cannot be obtained programmatically.\n\n### Available Functions\n\n{{ primitivesList }}\n\n{{ functionsList }}\n{{ if discoveryMode }}\n\n{{ if hasModules }}\n### Available Modules\n{{ modulesList }}\n{{ /if }}\n{{ if hasDiscoveredDocs }}\n### Discovered Tool Docs\n\nWhen `inputs.discoveredToolDocs` is provided, it contains tool docs fetched this run. Use them directly. Only re-run discovery for modules/functions not listed there.\n{{ /if }}\n{{ /if }}\n{{ if hasSkills }}\n### Loaded Skills\n\nWhen `inputs.loadedSkills` is provided, it contains skill guides loaded via the runtime-exposed `discover` primitive or forward-time skills. Apply relevant guides directly. Call `discover` with skills to load additional skills as needed.\n{{ if skillUsageMode }}\n\nIf `used(...)` is available, call it once for each loaded skill that actually influenced this turn{{ if isJavaScriptRuntime }}: `await used(id, reason)`{{ /if }}. Use the skill's rendered `ID:` value. Keep reasons short. Do not report skills that were merely loaded or scanned.\n{{ /if }}\n{{ /if }}\n{{ if memoriesMode }}\n\n### Memories\n\n`inputs.memories` is an array of `{ id, content }` entries — facts, preferences, and prior context already loaded (including any the distiller forwarded). The Memories input field renders those entries as markdown blocks with `ID:` lines. Scan them before deciding what to do. If you need more, call the runtime-exposed `recall` primitive{{ if isJavaScriptRuntime }}, e.g. `await recall(['…', '…'])`,{{ /if }} and matched memories are appended to `inputs.memories` for the next turn.\n{{ if memoryUsageMode }}\n\nIf `used(...)` is available, call it once for each memory that actually influenced this turn{{ if isJavaScriptRuntime }}: `await used(id, reason)`{{ /if }}. Use the memory's rendered `ID:` value or `inputs.memories[n].id`. Keep reasons short. Do not report memories that were merely loaded or scanned.\n{{ /if }}\n{{ /if }}\n\n### How to Work\n\n- Start from `inputs.executorRequest`, `inputs.distilledContext`, non-context task inputs, and prior successful Action Log results. Don't repeat probes already in the Action Log.\n- Treat direct action requests as work to attempt with available functions. If a function fails or the environment denies the action, capture the real error, status, output, or exception in the evidence for the responder.\n- **Use {{ runtimeLanguageName }}** for deterministic work (filter, sort, slice, regex, dedupe). **Use `llmQuery`** only to interpret narrowed text — never pass raw `inputs.*` to it.\n- Discovery calls (`discover`) can appear alongside other code — the runtime runs them first automatically.\n{{ if isJavaScriptRuntime }}\n- Prefer one compact `console.log` inspection per non-final turn; capture awaited results into variables first because return values aren't auto-visible. If the task is complete, finish with `await final(\"...\", { result })` instead of logging.\n{{ else }}\n- Capture runtime results into variables when the language requires it; inspect intermediate values using the output/print mechanism described in the runtime usage instructions.\n{{ /if }}\n- Before calling `askClarification`, check whether any available function can resolve the need first.\n{{ if hasAgentStatusCallback }}\n- Keep the user updated: call the runtime-exposed `reportSuccess` primitive after completing sub-tasks and `reportFailure` when something goes wrong{{ if isJavaScriptRuntime }} (for example, `await reportSuccess(message)`){{ /if }}.\n{{ /if }}\n{{ if isJavaScriptRuntime }}\n\n```{{ runtimeCodeFenceLanguage }}\nconst narrowed = inputs.emails\n  .filter(e => e.subject.toLowerCase().includes('refund'))\n  .map(e => ({ from: e.from, subject: e.subject, body: e.body.slice(0, 800) }));\n\nconst plan = await llmQuery([{\n  query: 'Determine which messages require a refund response and draft a compact action plan.',\n  context: { emails: narrowed }\n}]);\nconsole.log(plan);\n```\n{{ /if }}\n\n### Output Contract\n\nThe `{{ runtimeCodeFieldTitle }}` field value must be runnable {{ runtimeLanguageName }} only. Do not put prose or plain labels like `task:` / `evidence:` inside the value.\n{{ if isJavaScriptRuntime }}\nNever combine `console.log` with `final()` or `askClarification()` in the same turn.\n{{ /if }}\n\n{{ if isJavaScriptRuntime }}\nWhen done, call `await final(task, evidence)`:\n{{ else }}\nWhen done, call the runtime-exposed `final(task, evidence)` primitive:\n{{ /if }}\n\n- `task` — a one-line instruction the **responder** will follow when writing the user-facing output fields (e.g. \"Answer the user's question using the matched emails\").\n- `evidence` — the curated data the responder will read to follow `task`. Pass narrowed runtime values with only the fields that matter, not raw `inputs.*`. Use plain keys (for example, `matchedEmails`) — don't wrap under the output field name.\n\nDo not pre-format the answer; the responder writes the output fields.\n\nValid completion turns:\n\n{{ if isJavaScriptRuntime }}\n```{{ runtimeCodeFenceLanguage }}\nawait final(\"Answer the user's question using the gathered evidence\", { evidence });\n```\n\n```{{ runtimeCodeFenceLanguage }}\nawait askClarification(\"Which file should I analyze?\");\n```\n{{ else }}\nCompletion turns must call the runtime-exposed `final` or `askClarification` primitive using the syntax described in the runtime usage instructions.\n{{ /if }}\n\n## {{ runtimeLanguageName }} Runtime Usage Instructions\n{{ runtimeUsageInstructions }}\n";
     readonly 'rlm/responder.md': "## Answer Synthesis Agent\n\nYou synthesize the final answer from the evidence the actor gathered. You do not run code, call tools, or invoke agents — you read input fields and write the output fields.\n\n### Reading the actor's payload\n\n`Context Data` has two keys:\n\n- `task` — a one-line instruction telling you what to write into the output fields.\n- `evidence` — the data the actor curated for you to follow that instruction.\n\n### Rules\n\n1. Follow `Context Data.task` using `Context Data.evidence` and any other input fields provided.\n2. When emitting a JSON output field, write the value flat — do **not** wrap it under a key matching the field's title. The field is already named.\n3. If `evidence` lacks sufficient information, give the best possible answer from what's available across all input fields.\n4. Do not contradict actor evidence. If evidence contains a tool result, failure, status, output, or exception, report that result rather than inventing a capability limit.\n\n### Context variables that were analyzed (metadata only)\n{{ contextVarSummary }}\n{{ if hasAgentIdentity }}\n\n### Agent Identity\n\nUser-facing identity:\n{{ agentIdentityText }}\n{{ /if }}\n";
 };
 type TemplateId = keyof typeof promptTemplates;
@@ -4565,6 +4518,9 @@ interface AxAgentic<IN extends AxGenIn, OUT extends AxGenOut> extends AxProgramm
     getFunction(): AxFunction;
 }
 type AxAnyAgentic = AxAgentic<any, any>;
+type AxFunctionProvider = {
+    toFunction(): AxFunction | readonly AxFunction[];
+};
 type AxAgentIdentity = {
     name: string;
     description: string;
@@ -4597,7 +4553,7 @@ type AxAgentFunction = Omit<AxFunction, 'description'> & {
     _alwaysInclude?: boolean;
 };
 type AxAgentFunctionGroup = AxAgentFunctionModuleMeta & {
-    functions: readonly Omit<AxAgentFunction, 'namespace'>[];
+    functions: readonly (Omit<AxAgentFunction, 'namespace'> | AxFunctionProvider)[];
 };
 type AxAgentTestCompletionPayload = {
     type: 'final' | 'askClarification';
@@ -4682,7 +4638,7 @@ declare class AxAgentClarificationError extends Error {
     }>);
     getState(): AxAgentState | undefined;
 }
-type AxAgentFunctionCollection = readonly (AxAgentFunction | AxAnyAgentic)[] | readonly AxAgentFunctionGroup[];
+type AxAgentFunctionCollection = readonly (AxAgentFunction | AxAnyAgentic | AxFunctionProvider)[] | readonly AxAgentFunctionGroup[];
 type AxContextFieldInput = string | {
     field: string;
     promptMaxChars?: number;
@@ -4707,9 +4663,9 @@ type AxAgentActorTurnCallbackArgs = {
     actionLogEntryCount: number;
     /** Number of guidance log entries recorded after processing this turn. */
     guidanceLogEntryCount: number;
-    /** Full actor AxGen output for the turn, including javascriptCode and any actor fields. */
+    /** Full actor AxGen output for the turn, including the runtime code field and any actor fields. */
     executorResult: Record<string, unknown>;
-    /** Normalized JavaScript that was executed for this turn. */
+    /** Normalized runtime code that was executed for this turn. */
     code: string;
     /**
      * Raw runtime execution result before formatting or truncation.
@@ -4733,14 +4689,6 @@ type AxAgentActorTurnCallbackArgs = {
     }>;
 };
 type AxAgentActorTurnCallback = (args: AxAgentActorTurnCallbackArgs) => void | Promise<void>;
-/**
- * @deprecated Use AxAgentActorTurnCallbackArgs.
- */
-type AxAgentExecutorTurnCallbackArgs = AxAgentActorTurnCallbackArgs;
-/**
- * @deprecated Use AxAgentActorTurnCallback.
- */
-type AxAgentExecutorTurnCallback = AxAgentActorTurnCallback;
 
 /**
  * RLM (Recursive Language Model) interfaces and prompt builder.
@@ -4753,11 +4701,30 @@ type AgentIdentityPrompt = Readonly<{
     name: string;
     description: string;
 }>;
+type AxRuntimeCallableFormatArgs = Readonly<{
+    qualifiedName: string;
+    description?: string;
+    parameters?: AxFunctionJSONSchema;
+    returns?: AxFunctionJSONSchema;
+}>;
+type AxRuntimePrimitiveOverrideMap = ReadonlyMap<string, readonly string[]> | Readonly<Record<string, readonly string[]>>;
+type AxRuntimeLanguageInfo = Readonly<{
+    languageName: string;
+    codeFieldName: string;
+    codeFieldTitle: string;
+    codeFenceLanguage: string;
+    isJavaScript: boolean;
+}>;
 /**
  * A code runtime that can create persistent sessions.
  * Implement this interface for your target runtime (Node.js, browser, WASM, etc.).
  */
 interface AxCodeRuntime {
+    /**
+     * Human-readable language name for generated actor code.
+     * Defaults to JavaScript when omitted for backwards compatibility.
+     */
+    readonly language?: string;
     createSession(globals?: Record<string, unknown>, options?: {
         shouldBubbleError?: (err: unknown) => boolean;
     }): AxCodeSession;
@@ -4766,11 +4733,17 @@ interface AxCodeRuntime {
      * Use this for execution semantics that differ by runtime/language.
      */
     getUsageInstructions(): string;
+    /**
+     * Optional language-native prompt text for built-in actor primitives such as
+     * final, askClarification, discover, and recall.
+     */
+    getPrimitiveOverrides?(): AxRuntimePrimitiveOverrideMap | undefined;
+    /**
+     * Optional language-native formatter for callable tools exposed in the
+     * runtime. Execution still happens inside the runtime session.
+     */
+    formatCallable?(args: AxRuntimeCallableFormatArgs): string;
 }
-/**
- * @deprecated Use `AxCodeRuntime` instead.
- */
-type AxCodeInterpreter = AxCodeRuntime;
 type AxCodeSessionSnapshotEntry = {
     name: string;
     type: string;
@@ -4870,10 +4843,6 @@ interface AxRLMConfig {
      * the formatted action-log output.
      */
     actorTurnCallback?: AxAgentActorTurnCallback;
-    /**
-     * @deprecated Use actorTurnCallback.
-     */
-    executorTurnCallback?: AxAgentExecutorTurnCallback;
     /**
      * Called when AxAgent measures context pressure or changes compacted context state.
      * Intended for observability; callback failures are ignored.
@@ -4891,6 +4860,10 @@ interface AxRLMConfig {
  */
 declare function axBuildDistillerDefinition(baseDefinition: string | undefined, contextFields: readonly AxIField[], options: Readonly<{
     runtimeUsageInstructions?: string;
+    runtimeLanguageName?: string;
+    runtimeCodeFieldTitle?: string;
+    runtimeCodeFenceLanguage?: string;
+    isJavaScriptRuntime?: boolean;
     promptLevel?: 'default' | 'detailed';
     hasInspectRuntime?: boolean;
     hasLiveRuntimeState?: boolean;
@@ -4915,6 +4888,11 @@ declare function axBuildDistillerDefinition(baseDefinition: string | undefined,
  */
 declare function axBuildExecutorDefinition(baseDefinition: string | undefined, contextFields: readonly AxIField[], responderOutputFields: readonly AxIField[], options: Readonly<{
     runtimeUsageInstructions?: string;
+    runtimeLanguageName?: string;
+    runtimeCodeFieldTitle?: string;
+    runtimeCodeFenceLanguage?: string;
+    isJavaScriptRuntime?: boolean;
+    formatCallable?: AxCodeRuntime['formatCallable'];
     promptLevel?: 'default' | 'detailed';
     hasInspectRuntime?: boolean;
     hasLiveRuntimeState?: boolean;
@@ -5149,14 +5127,13 @@ declare class AxAgentContextMap {
 
 /**
  * Demo traces for AxAgent's split architecture.
- * Actor demos use `{ javascriptCode }`.
+ * Actor demos use the runtime code field (`javascriptCode` for JavaScript,
+ * `<language>Code` for other runtimes such as `pythonCode`).
  * Responder demos use the agent's output type + optional input fields.
  */
 type AxAgentDemos<IN extends AxGenIn, OUT extends AxGenOut, PREFIX extends string = string> = {
     programId: `${PREFIX}.actor`;
-    traces: (Record<string, AxFieldValue> & {
-        javascriptCode: string;
-    })[];
+    traces: Record<string, AxFieldValue>[];
 } | {
     programId: `${PREFIX}.responder`;
     traces: (OUT & Partial<IN>)[];
@@ -5333,13 +5310,6 @@ type AxAgentOptions<IN extends AxGenIn = AxGenIn> = Omit<AxProgramForwardOptions
      * result and the formatted action-log output.
      */
     actorTurnCallback?: AxAgentActorTurnCallback;
-    /**
-     * @deprecated Use actorTurnCallback.
-     *
-     * Called after each actor turn is recorded with both the raw runtime
-     * result and the formatted action-log output.
-     */
-    executorTurnCallback?: (args: AxAgentExecutorTurnCallbackArgs) => void | Promise<void>;
     /**
      * Called when AxAgent measures context pressure or creates/clears compacted
      * context. Use for observability and evaluation; failures are ignored.
@@ -5449,10 +5419,6 @@ type AxAgentJudgeEvalOutput = {
     reasoning: string;
     quality: string;
 };
-type AxNormalizedAgentEvalDataset<IN = any> = {
-    train: readonly AxAgentEvalTask<IN>[];
-    validation?: readonly AxAgentEvalTask<IN>[];
-};
 /** Forward options forwarded to the `AxGen` spawned by each `llmQuery(...)` call. */
 type AxAgentRecursionOptions = Partial<Omit<AxProgramForwardOptions<string>, 'functions'>>;
 
@@ -5567,22 +5533,11 @@ type AxAgentRuntimeExecutionContext = {
     executeTestCode: (code: string) => Promise<AxAgentTestResult>;
     close: () => void;
 };
-type AxMutableDiscoveryPromptState = {
-    modules: Map<string, string>;
-    functions: Map<string, string>;
-};
 type AxDiscoveryTurnSummary = {
     modules: Set<string>;
     functions: Set<string>;
     texts: Set<string>;
 };
-type AxMutableSkillsPromptState = {
-    loaded: Map<string, {
-        id: string;
-        name: string;
-        content: string;
-    }>;
-};
 type AxAgentOptimizationTargetDescriptor = {
     id: string;
     signature?: string;
@@ -5770,7 +5725,7 @@ declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAge
     setContextMap(map?: AxAgentContextMap | AxAgentContextMapSnapshot | string): void;
     _syncContextMapPrompt(): void;
     _updateContextMapFromPipelineState(ai: Readonly<AxAIService>, state: Readonly<Record<string, any>>, finalOutput?: unknown): Promise<void>;
-    setSignature(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>): void;
+    setSignature(signature: AxSignatureInput): void;
     applyOptimization(optimizedProgram: any): void;
     getOptimizableComponents(): readonly any[];
     applyOptimizedComponents(updates: Readonly<Record<string, string>>): void;
@@ -5800,9 +5755,9 @@ declare function agent<TInput extends Record<string, any>, TOutput extends Recor
 declare function agent(signature: Readonly<AxSignatureConfig>, config: AxAgentConfig<AxGenIn, AxGenOut>): AxAgent<AxGenIn, AxGenOut>;
 
 /**
- * RLM actor stage: a single AxGen program driven in a JS-runtime loop.
+ * RLM actor stage: a single AxGen program driven in a code-runtime loop.
  *
- * The actor generates JavaScript, the TypeScript loop executes it in a
+ * The actor generates runtime-language code, the TypeScript loop executes it in a
  * pluggable `AxCodeRuntime`, the result is appended to an action log, and the
  * loop continues until the actor terminates with `final(...)` /
  * `askClarification(...)` (or hits `maxTurns`).
@@ -5848,6 +5803,11 @@ declare class ActorAgentRLM<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut =
     private onContextEvent?;
     private contextPromptConfigByField;
     private functionDiscoveryEnabled;
+    private runtimeLanguageName;
+    private runtimeCodeFieldName;
+    private runtimeCodeFieldTitle;
+    private runtimeCodeFenceLanguage;
+    private isJavaScriptRuntime;
     private runtimeUsageInstructions;
     private enforceIncrementalConsoleTurns;
     private bubbleErrors?;
@@ -5934,7 +5894,7 @@ declare class ActorAgentRLM<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut =
         abortSignal?: AbortSignal;
         debug?: boolean;
     }>): Promise<AxAgentTestResult>;
-    setSignature(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>): void;
+    setSignature(signature: AxSignatureInput): void;
     applyOptimization(optimizedProgram: any): void;
     getOptimizableComponents(): readonly any[];
     applyOptimizedComponents(updates: Readonly<Record<string, string>>): void;
@@ -6043,6 +6003,8 @@ type AxRuntimePrimitiveExample = {
 declare const axRuntimePrimitives: readonly AxRuntimePrimitive[];
 
 declare enum AxAIAnthropicModel {
+    Claude48Opus = "claude-opus-4-8",
+    Claude47Opus = "claude-opus-4-7",
     Claude46Opus = "claude-opus-4-6",
     Claude46Sonnet = "claude-sonnet-4-6",
     Claude45Opus = "claude-opus-4-5-20251101",
@@ -6061,6 +6023,8 @@ declare enum AxAIAnthropicModel {
     ClaudeInstant12 = "claude-instant-1.2"
 }
 declare enum AxAIAnthropicVertexModel {
+    Claude48Opus = "claude-opus-4-8",
+    Claude47Opus = "claude-opus-4-7",
     Claude46Opus = "claude-opus-4-6",
     Claude46Sonnet = "claude-sonnet-4-6",
     Claude45Opus = "claude-opus-4-5@20251101",
@@ -6088,13 +6052,19 @@ type AxAIAnthropicThinkingWire = {
 } | {
     type: 'adaptive';
 };
-type AxAIAnthropicEffortLevel = 'low' | 'medium' | 'high' | 'max';
+type AxAIAnthropicEffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+type AxAIAnthropicTaskBudget = {
+    type: 'tokens';
+    total: number;
+    remaining?: number;
+};
 type AxAIAnthropicOutputConfig = {
     effort?: AxAIAnthropicEffortLevel;
     format?: {
         type: 'json_schema';
         schema: object;
     };
+    task_budget?: AxAIAnthropicTaskBudget;
 };
 type AxAIAnthropicEffortLevelMapping = {
     minimal?: AxAIAnthropicEffortLevel;
@@ -6146,9 +6116,15 @@ type AxAIAnthropicChatRequest = {
     model?: string;
     anthropic_version?: string;
     messages: ({
-        role: 'user';
-        content: string | (({
-            type: 'text';
+        role: 'system';
+        content: string | ({
+            type: 'text';
+            text: string;
+        } & AxAIAnthropicChatRequestCacheParam)[];
+    } | {
+        role: 'user';
+        content: string | (({
+            type: 'text';
             text: string;
         } & AxAIAnthropicChatRequestCacheParam) | ({
             type: 'image';
@@ -6212,10 +6188,16 @@ type AxAIAnthropicChatRequest = {
     top_k?: number;
     thinking?: AxAIAnthropicThinkingWire;
     output_config?: AxAIAnthropicOutputConfig;
+    speed?: 'fast';
     metadata?: {
         user_id: string;
     };
 };
+type AxAIAnthropicStopDetails = {
+    type: 'refusal';
+    category?: 'cyber' | 'bio' | string | null;
+    explanation?: string | null;
+};
 type AxAIAnthropicChatResponse = {
     id: string;
     type: 'message';
@@ -6239,13 +6221,15 @@ type AxAIAnthropicChatResponse = {
         signature?: string;
     })[];
     model: string;
-    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+    stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'refusal' | 'pause_turn' | 'model_context_window_exceeded';
+    stop_details?: AxAIAnthropicStopDetails | null;
     stop_sequence?: string;
     usage: {
         input_tokens: number;
         output_tokens: number;
         cache_creation_input_tokens?: number;
         cache_read_input_tokens?: number;
+        speed?: 'fast' | 'standard';
     };
 };
 type AxAIAnthropicChatError = {
@@ -6270,6 +6254,7 @@ interface AxAIAnthropicMessageStartEvent {
             output_tokens: number;
             cache_creation_input_tokens?: number;
             cache_read_input_tokens?: number;
+            speed?: 'fast' | 'standard';
         };
     };
 }
@@ -6322,11 +6307,13 @@ interface AxAIAnthropicContentBlockStopEvent {
 interface AxAIAnthropicMessageDeltaEvent {
     type: 'message_delta';
     delta: {
-        stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | null;
+        stop_reason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use' | 'refusal' | 'pause_turn' | 'model_context_window_exceeded' | null;
         stop_sequence: string | null;
+        stop_details?: AxAIAnthropicStopDetails | null;
     };
     usage: {
         output_tokens: number;
+        speed?: 'fast' | 'standard';
     };
 }
 interface AxAIAnthropicMessageStopEvent {
@@ -7284,37 +7271,21 @@ type AxAICohereEmbedResponse = {
     embeddings: number[][];
 };
 
+type AxAICohereOpenAIConfig = AxAIOpenAIConfig<AxAICohereModel, AxAICohereEmbedModel>;
 /**
- * Creates the default configuration for Cohere AI service
- * @returns A deep clone of the default Cohere configuration with CommandRPlus model and EmbedEnglishV30 embed model
- */
-declare const axAICohereDefaultConfig: () => AxAICohereConfig;
-/**
- * Creates a creative configuration for Cohere AI service with more flexible parameters
- * @returns A deep clone of the creative Cohere configuration with CommandR model and EmbedEnglishV30 embed model
+ * Creates the default configuration for Cohere AI service.
  */
-declare const axAICohereCreativeConfig: () => AxAICohereConfig;
+declare const axAICohereDefaultConfig: () => AxAICohereOpenAIConfig;
 /**
- * Configuration arguments for initializing the Cohere AI service
- * @template TModelKey - The type of model keys supported
+ * Creates a creative configuration for Cohere AI service.
  */
-interface AxAICohereArgs<TModelKey> {
-    name: 'cohere';
-    apiKey: string;
-    config?: Readonly<Partial<AxAICohereConfig>>;
-    options?: Readonly<AxAIServiceOptions>;
-    models?: AxAIInputModelList<AxAICohereModel, AxAICohereEmbedModel, TModelKey>;
-}
+declare const axAICohereCreativeConfig: () => AxAICohereOpenAIConfig;
+type AxAICohereArgs<TModelKey> = AxAIOpenAIArgs<'cohere', AxAICohereModel, AxAICohereEmbedModel, TModelKey>;
 /**
- * Main Cohere AI service class that extends the base AI implementation
- * @template TModelKey - The type of model keys supported
+ * Cohere provider using Cohere's OpenAI compatibility endpoint.
  */
-declare class AxAICohere<TModelKey> extends AxBaseAI<AxAICohereModel, AxAICohereEmbedModel, AxAICohereChatRequest, AxAICohereEmbedRequest, AxAICohereChatResponse, AxAICohereChatResponseDelta, AxAICohereEmbedResponse, TModelKey> {
-    /**
-     * Creates a new instance of AxAICohere
-     * @param args - Configuration arguments including API key, config, options, and models
-     */
-    constructor({ apiKey, config, options, models, }: Readonly<Omit<AxAICohereArgs<TModelKey>, 'name'>>);
+declare class AxAICohere<TModelKey> extends AxAIOpenAIBase<AxAICohereModel, AxAICohereEmbedModel, TModelKey> {
+    constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAICohereArgs<TModelKey>, 'name'>>);
 }
 
 /**
@@ -7776,25 +7747,6 @@ declare class AxAIGoogleGemini<TModelKey = string> extends AxBaseAI<AxAIGoogleGe
     constructor({ apiKey, projectId, region, endpointId, config, options, models, modelInfo, }: Readonly<Omit<AxAIGoogleGeminiArgs<TModelKey>, 'name'>>);
 }
 
-declare enum AxAIGroqModel {
-    Llama3_8B = "llama3-8b-8192",
-    Llama33_70B = "llama-3.3-70b-versatile",
-    Mixtral_8x7B = "mixtral-8x7b-32768",
-    Gemma2_9B = "gemma2-9b-it"
-}
-
-type AxAIGroqArgs<TModelKey> = AxAIOpenAIArgs<'groq', AxAIGroqModel, undefined, TModelKey> & {
-    options?: Readonly<AxAIServiceOptions> & {
-        tokensPerMinute?: number;
-    };
-    modelInfo?: AxModelInfo[];
-};
-declare class AxAIGroq<TModelKey> extends AxAIOpenAIBase<AxAIGroqModel, undefined, TModelKey> {
-    constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAIGroqArgs<TModelKey>, 'name'>>);
-    setOptions: (options: Readonly<AxAIServiceOptions>) => void;
-    private newRateLimiter;
-}
-
 declare enum AxAIHuggingFaceModel {
     MetaLlama270BChatHF = "meta-llama/Llama-2-70b-chat-hf"
 }
@@ -7903,50 +7855,6 @@ declare class AxAIMistral<TModelKey> extends AxAIOpenAIBase<AxAIMistralModel, Ax
     private updateMessages;
 }
 
-/**
- * Configuration type for Ollama AI service
- */
-type AxAIOllamaAIConfig = AxAIOpenAIConfig<string, string>;
-type AxAIOllamaChatRequest = AxAIOpenAIChatRequest<string> & {
-    think?: boolean;
-};
-/**
- * Creates default configuration for Ollama AI service
- * @returns Default configuration object with nous-hermes2 model and all-minilm embed model
- */
-declare const axAIOllamaDefaultConfig: () => AxAIOllamaAIConfig;
-/**
- * Creates default creative configuration for Ollama AI service
- * @returns Creative configuration object with nous-hermes2 model and all-minilm embed model
- */
-declare const axAIOllamaDefaultCreativeConfig: () => AxAIOllamaAIConfig;
-/**
- * Arguments type for initializing Ollama AI service
- * @template TModelKey - Type for model key
- */
-type AxAIOllamaArgs<TModelKey> = AxAIOpenAIArgs<'ollama', string, string, TModelKey> & {
-    model?: string;
-    embedModel?: string;
-    url?: string;
-};
-/**
- * Ollama AI service implementation that extends OpenAI base functionality
- * Provides access to locally hosted Ollama models with OpenAI-compatible API
- * @template TModelKey - Type for model key
- */
-declare class AxAIOllama<TModelKey> extends AxAIOpenAIBase<string, string, TModelKey, AxAIOllamaChatRequest> {
-    /**
-     * Creates a new Ollama AI service instance
-     * @param args - Configuration arguments for the Ollama service
-     * @param args.apiKey - API key for authentication (defaults to 'not-set')
-     * @param args.url - Base URL for the Ollama API (defaults to 'http://localhost:11434/v1')
-     * @param args.config - Additional configuration options
-     * @param args.options - Service options
-     * @param args.models - Available models configuration
-     */
-    constructor({ apiKey, url, config, options, models, }: Readonly<Omit<AxAIOllamaArgs<TModelKey>, 'name'>>);
-}
-
 declare enum AxAIOpenAIResponsesModel {
     GPT4 = "gpt-4",
     GPT41 = "gpt-4.1",
@@ -8391,7 +8299,7 @@ interface AxAIOpenAIResponsesErrorEvent extends AxAIOpenAIResponsesStreamEventBa
     readonly param: string | null;
 }
 type AxAIOpenAIResponsesStreamEvent = AxAIOpenAIResponsesResponseCreatedEvent | AxAIOpenAIResponsesResponseInProgressEvent | AxAIOpenAIResponsesResponseCompletedEvent | AxAIOpenAIResponsesResponseFailedEvent | AxAIOpenAIResponsesResponseIncompleteEvent | AxAIOpenAIResponsesResponseQueuedEvent | AxAIOpenAIResponsesOutputItemAddedEvent | AxAIOpenAIResponsesOutputItemDoneEvent | AxAIOpenAIResponsesContentPartAddedEvent | AxAIOpenAIResponsesContentPartDoneEvent | AxAIOpenAIResponsesOutputTextDeltaEvent | AxAIOpenAIResponsesOutputTextDoneEvent | AxAIOpenAIResponsesRefusalDeltaEvent | AxAIOpenAIResponsesRefusalDoneEvent | AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent | AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent | AxAIOpenAIResponsesFileSearchCallInProgressEvent | AxAIOpenAIResponsesFileSearchCallSearchingEvent | AxAIOpenAIResponsesFileSearchCallCompletedEvent | AxAIOpenAIResponsesWebSearchCallInProgressEvent | AxAIOpenAIResponsesWebSearchCallSearchingEvent | AxAIOpenAIResponsesWebSearchCallCompletedEvent | AxAIOpenAIResponsesReasoningDeltaEvent | AxAIOpenAIResponsesReasoningDoneEvent | AxAIOpenAIResponsesReasoningSummaryPartAddedEvent | AxAIOpenAIResponsesReasoningSummaryPartDoneEvent | AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent | AxAIOpenAIResponsesReasoningSummaryTextDoneEvent | AxAIOpenAIResponsesReasoningSummaryDeltaEvent | AxAIOpenAIResponsesReasoningSummaryDoneEvent | AxAIOpenAIResponsesImageGenerationCallInProgressEvent | AxAIOpenAIResponsesImageGenerationCallGeneratingEvent | AxAIOpenAIResponsesImageGenerationCallCompletedEvent | AxAIOpenAIResponsesImageGenerationCallPartialImageEvent | AxAIOpenAIResponsesMCPCallInProgressEvent | AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent | AxAIOpenAIResponsesMCPCallArgumentsDoneEvent | AxAIOpenAIResponsesMCPCallCompletedEvent | AxAIOpenAIResponsesMCPCallFailedEvent | AxAIOpenAIResponsesMCPListToolsInProgressEvent | AxAIOpenAIResponsesMCPListToolsCompletedEvent | AxAIOpenAIResponsesMCPListToolsFailedEvent | AxAIOpenAIResponsesOutputTextAnnotationAddedEvent | AxAIOpenAIResponsesErrorEvent;
-interface AxAIOpenAIResponsesResponseDelta {
+interface OpenAIResponsesResponseDelta {
     readonly id?: string;
     readonly model?: string;
     readonly event?: string;
@@ -8422,7 +8330,6 @@ interface AxAIOpenAIResponsesResponseDelta {
         };
     } | null;
 }
-type ResponsesReqUpdater<TModel, TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> = (req: Readonly<TResponsesReq>) => Readonly<TResponsesReq>;
 type AxAIOpenAIResponsesConfig<TModel, TEmbedModel> = Omit<AxModelConfig, 'topK'> & {
     model: TModel;
     embedModel?: TEmbedModel;
@@ -8508,7 +8415,7 @@ interface AxAIOpenAIResponsesBaseArgs<TModel, TEmbedModel, TModelKey, TResponses
 /**
  * Base class for OpenAI AI services using the /v1/responses API endpoint
  */
-declare class AxAIOpenAIResponsesBase<TModel, TEmbedModel, TModelKey, TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> extends AxBaseAI<TModel, TEmbedModel, AxAIOpenAIResponsesRequest<TModel>, AxAIOpenAIEmbedRequest<TEmbedModel>, AxAIOpenAIResponsesResponse, AxAIOpenAIResponsesResponseDelta, AxAIOpenAIEmbedResponse, TModelKey> {
+declare class AxAIOpenAIResponsesBase<TModel, TEmbedModel, TModelKey, TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> extends AxBaseAI<TModel, TEmbedModel, AxAIOpenAIResponsesRequest<TModel>, AxAIOpenAIEmbedRequest<TEmbedModel>, AxAIOpenAIResponsesResponse, OpenAIResponsesResponseDelta, AxAIOpenAIEmbedResponse, TModelKey> {
     constructor({ apiKey, config, options, apiURL, modelInfo, models, responsesReqUpdater, supportFor, }: Readonly<AxAIOpenAIResponsesBaseArgs<TModel, TEmbedModel, TModelKey, TResponsesReq>>);
 }
 /**
@@ -8524,17 +8431,6 @@ declare class AxAIOpenAIResponses<TModelKey = string> extends AxAIOpenAIResponse
     constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAIOpenAIResponsesArgs<'openai-responses', AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel, TModelKey>, 'name'>>);
 }
 
-type OpenRouterConfig = AxAIOpenAIConfig<string, unknown>;
-declare const axAIOpenRouterDefaultConfig: () => OpenRouterConfig;
-type AxAIOpenRouterArgs<TModelKey> = AxAIOpenAIArgs<'openrouter', string, unknown, TModelKey> & {
-    referer?: string;
-    title?: string;
-    options?: Readonly<AxAIServiceOptions>;
-};
-declare class AxAIOpenRouter<TModelKey> extends AxAIOpenAIBase<string, unknown, TModelKey> {
-    constructor({ apiKey, config, options, models, modelInfo, referer, title, }: Readonly<Omit<AxAIOpenRouterArgs<TModelKey>, 'name'>>);
-}
-
 declare enum AxAIRekaModel {
     RekaCore = "reka-core",
     RekaFlash = "reka-flash",
@@ -8606,224 +8502,11 @@ declare const axAIRekaDefaultConfig: () => AxAIRekaConfig;
 declare const axAIRekaBestConfig: () => AxAIRekaConfig;
 declare const axAIRekaCreativeConfig: () => AxAIRekaConfig;
 declare const axAIRekaFastConfig: () => AxAIRekaConfig;
-interface AxAIRekaArgs<TModelKey> {
-    name: 'reka';
-    apiKey: string;
-    apiURL?: string;
-    config?: Readonly<Partial<AxAIRekaConfig>>;
-    options?: Readonly<AxAIServiceOptions & {
-        streamingUsage?: boolean;
-    }>;
-    modelInfo?: Readonly<AxModelInfo[]>;
-    models?: AxAIInputModelList<AxAIRekaModel, undefined, TModelKey>;
-}
-declare class AxAIReka<TModelKey> extends AxBaseAI<AxAIRekaModel, undefined, AxAIRekaChatRequest, unknown, AxAIRekaChatResponse, AxAIRekaChatResponseDelta, unknown, TModelKey> {
+type AxAIRekaArgs<TModelKey> = AxAIOpenAIArgs<'reka', AxAIRekaModel, undefined, TModelKey>;
+declare class AxAIReka<TModelKey> extends AxAIOpenAIBase<AxAIRekaModel, undefined, TModelKey> {
     constructor({ apiKey, config, options, apiURL, modelInfo, models, }: Readonly<Omit<AxAIRekaArgs<TModelKey>, 'name'>>);
 }
 
-declare enum AxAITogetherModel {
-    KimiK25 = "moonshotai/Kimi-K2.5",
-    KimiK2Instruct0905 = "moonshotai/Kimi-K2-Instruct-0905",
-    KimiK2Thinking = "moonshotai/Kimi-K2-Thinking",
-    DeepSeekV31 = "deepseek-ai/DeepSeek-V3.1",
-    DeepSeekR1 = "deepseek-ai/DeepSeek-R1",
-    GPTOSS120B = "openai/gpt-oss-120b",
-    GPTOSS20B = "openai/gpt-oss-20b",
-    Qwen35_397B = "Qwen/Qwen3.5-397B-A17B",
-    Qwen3CoderNext = "Qwen/Qwen3-Coder-Next-FP8",
-    Qwen3Coder480B = "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
-    Qwen3_235BInstruct2507 = "Qwen/Qwen3-235B-A22B-Instruct-2507-tput",
-    Qwen3_235BThinking2507 = "Qwen/Qwen3-235B-A22B-Thinking-2507",
-    Qwen3Next80BInstruct = "Qwen/Qwen3-Next-80B-A3B-Instruct",
-    Qwen3Next80BThinking = "Qwen/Qwen3-Next-80B-A3B-Thinking",
-    GLM5 = "zai-org/GLM-5",
-    GLM47 = "zai-org/GLM-4.7",
-    Llama4Maverick = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8",
-    Llama33_70B = "meta-llama/Llama-3.3-70B-Instruct-Turbo"
-}
-type AxAITogetherChatModel = AxAITogetherModel | (string & {});
-
-type TogetherAIConfig = AxAIOpenAIConfig<AxAITogetherChatModel, unknown>;
-declare const axAITogetherDefaultConfig: () => TogetherAIConfig;
-type AxAITogetherArgs<TModelKey> = AxAIOpenAIArgs<'together', AxAITogetherChatModel, unknown, TModelKey>;
-declare class AxAITogether<TModelKey> extends AxAIOpenAIBase<AxAITogetherChatModel, unknown, TModelKey> {
-    constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAITogetherArgs<TModelKey>, 'name'>>);
-}
-
-/**
- * WebLLM: Models for text generation
- * Based on WebLLM's supported models
- */
-declare enum AxAIWebLLMModel {
-    Llama31_8B_Instruct = "Llama-3.1-8B-Instruct-q4f32_1-MLC",
-    Llama31_70B_Instruct = "Llama-3.1-70B-Instruct-q4f16_1-MLC",
-    Llama32_1B_Instruct = "Llama-3.2-1B-Instruct-q4f32_1-MLC",
-    Llama32_3B_Instruct = "Llama-3.2-3B-Instruct-q4f32_1-MLC",
-    Mistral7B_Instruct = "Mistral-7B-Instruct-v0.3-q4f32_1-MLC",
-    Phi35_Mini_Instruct = "Phi-3.5-mini-instruct-q4f32_1-MLC",
-    Gemma2_2B_Instruct = "gemma-2-2b-it-q4f32_1-MLC",
-    Gemma2_9B_Instruct = "gemma-2-9b-it-q4f32_1-MLC",
-    Qwen2_5_0_5B_Instruct = "Qwen2.5-0.5B-Instruct-q4f32_1-MLC",
-    Qwen2_5_1_5B_Instruct = "Qwen2.5-1.5B-Instruct-q4f32_1-MLC",
-    Qwen2_5_3B_Instruct = "Qwen2.5-3B-Instruct-q4f32_1-MLC",
-    Qwen2_5_7B_Instruct = "Qwen2.5-7B-Instruct-q4f32_1-MLC"
-}
-/**
- * WebLLM: Model options for text generation
- */
-type AxAIWebLLMConfig = AxModelConfig & {
-    model: AxAIWebLLMModel;
-    logitBias?: Record<number, number>;
-    logProbs?: boolean;
-    topLogprobs?: number;
-};
-/**
- * WebLLM: Chat request structure
- * Based on OpenAI-compatible API from WebLLM
- */
-type AxAIWebLLMChatRequest = {
-    model: AxAIWebLLMModel;
-    messages: Array<{
-        role: 'system' | 'user' | 'assistant' | 'function';
-        content?: string;
-        name?: string;
-        function_call?: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    temperature?: number;
-    top_p?: number;
-    max_tokens?: number;
-    stream?: boolean;
-    stop?: string | string[];
-    presence_penalty?: number;
-    frequency_penalty?: number;
-    logit_bias?: Record<number, number>;
-    logprobs?: boolean;
-    top_logprobs?: number;
-    n?: number;
-    tools?: Array<{
-        type: 'function';
-        function: {
-            name: string;
-            description: string;
-            parameters: object;
-        };
-    }>;
-    tool_choice?: 'none' | 'auto' | {
-        type: 'function';
-        function: {
-            name: string;
-        };
-    };
-};
-/**
- * WebLLM: Chat response structure
- */
-type AxAIWebLLMChatResponse = {
-    id: string;
-    object: 'chat.completion';
-    created: number;
-    model: AxAIWebLLMModel;
-    choices: Array<{
-        index: number;
-        message: {
-            role: 'assistant';
-            content?: string;
-            tool_calls?: Array<{
-                id: string;
-                type: 'function';
-                function: {
-                    name: string;
-                    arguments: string;
-                };
-            }>;
-        };
-        finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
-        logprobs?: {
-            content: Array<{
-                token: string;
-                logprob: number;
-                bytes: number[];
-                top_logprobs: Array<{
-                    token: string;
-                    logprob: number;
-                    bytes: number[];
-                }>;
-            }>;
-        };
-    }>;
-    usage: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-};
-/**
- * WebLLM: Streaming chat response structure
- */
-type AxAIWebLLMChatResponseDelta = {
-    id: string;
-    object: 'chat.completion.chunk';
-    created: number;
-    model: AxAIWebLLMModel;
-    choices: Array<{
-        index: number;
-        delta: {
-            role?: 'assistant';
-            content?: string;
-            tool_calls?: Array<{
-                index: number;
-                id?: string;
-                type?: 'function';
-                function?: {
-                    name?: string;
-                    arguments?: string;
-                };
-            }>;
-        };
-        finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
-        logprobs?: {
-            content: Array<{
-                token: string;
-                logprob: number;
-                bytes: number[];
-                top_logprobs: Array<{
-                    token: string;
-                    logprob: number;
-                    bytes: number[];
-                }>;
-            }>;
-        };
-    }>;
-    usage?: {
-        prompt_tokens: number;
-        completion_tokens: number;
-        total_tokens: number;
-    };
-};
-/**
- * WebLLM doesn't support embeddings natively
- * This is a placeholder for consistency with the framework
- */
-type AxAIWebLLMEmbedModel = never;
-type AxAIWebLLMEmbedRequest = never;
-type AxAIWebLLMEmbedResponse = never;
-
-declare const axAIWebLLMDefaultConfig: () => AxAIWebLLMConfig;
-declare const axAIWebLLMCreativeConfig: () => AxAIWebLLMConfig;
-interface AxAIWebLLMArgs<TModelKey> {
-    name: 'webllm';
-    engine: any;
-    config?: Readonly<Partial<AxAIWebLLMConfig>>;
-    options?: Readonly<AxAIServiceOptions>;
-    models?: AxAIInputModelList<AxAIWebLLMModel, AxAIWebLLMEmbedModel, TModelKey>;
-}
-declare class AxAIWebLLM<TModelKey> extends AxBaseAI<AxAIWebLLMModel, AxAIWebLLMEmbedModel, AxAIWebLLMChatRequest, AxAIWebLLMEmbedRequest, AxAIWebLLMChatResponse, AxAIWebLLMChatResponseDelta, AxAIWebLLMEmbedResponse, TModelKey> {
-    constructor({ engine, config, options, models, }: Readonly<Omit<AxAIWebLLMArgs<TModelKey>, 'name'>>);
-}
-
 declare enum AxAIGrokModel {
     Grok43 = "grok-4.3",
     Grok43Latest = "grok-4.3-latest",
@@ -8895,8 +8578,8 @@ declare class AxAIGrok<TModelKey> extends AxAIOpenAIBase<AxAIGrokModel, AxAIGrok
     speak(req: Readonly<AxSpeechRequest<AxAIGrokModel | TModelKey>>, options?: Readonly<AxAIServiceOptions>): Promise<AxSpeechResponse>;
 }
 
-type AxAIArgs<TModelKey> = AxAIOpenAIArgs<'openai', AxAIOpenAIModel, AxAIOpenAIEmbedModel, TModelKey> | AxAIOpenAIResponsesArgs<'openai-responses', AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel, TModelKey> | AxAIAzureOpenAIArgs<TModelKey> | AxAITogetherArgs<TModelKey> | AxAIOpenRouterArgs<TModelKey> | AxAIAnthropicArgs<TModelKey> | AxAIGroqArgs<TModelKey> | AxAIGoogleGeminiArgs<TModelKey> | AxAICohereArgs<TModelKey> | AxAIHuggingFaceArgs<TModelKey> | AxAIMistralArgs<TModelKey> | AxAIDeepSeekArgs<TModelKey> | AxAIOllamaArgs<TModelKey> | AxAIRekaArgs<TModelKey> | AxAIGrokArgs<TModelKey> | AxAIWebLLMArgs<TModelKey>;
-type AxAIModels = AxAIOpenAIModel | AxAIAnthropicModel | AxAIGroqModel | AxAIGoogleGeminiModel | AxAICohereModel | AxAIHuggingFaceModel | AxAIMistralModel | AxAIDeepSeekModel | AxAIGrokModel | AxAIWebLLMModel;
+type AxAIArgs<TModelKey> = AxAIOpenAIArgs<'openai', AxAIOpenAIModel, AxAIOpenAIEmbedModel, TModelKey> | AxAIOpenAIResponsesArgs<'openai-responses', AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel, TModelKey> | AxAIAzureOpenAIArgs<TModelKey> | AxAIAnthropicArgs<TModelKey> | AxAIGoogleGeminiArgs<TModelKey> | AxAICohereArgs<TModelKey> | AxAIHuggingFaceArgs<TModelKey> | AxAIMistralArgs<TModelKey> | AxAIDeepSeekArgs<TModelKey> | AxAIRekaArgs<TModelKey> | AxAIGrokArgs<TModelKey>;
+type AxAIModels = AxAIOpenAIModel | AxAIAnthropicModel | AxAIGoogleGeminiModel | AxAICohereModel | AxAIHuggingFaceModel | AxAIMistralModel | AxAIDeepSeekModel | AxAIGrokModel;
 type AxAIEmbedModels = AxAIOpenAIEmbedModel | AxAIGoogleGeminiEmbedModel | AxAICohereEmbedModel;
 type ExtractModelKeysAndValues<T> = T extends readonly {
     key: infer K;
@@ -8918,21 +8601,16 @@ type InferTModelKey<T> = T extends {
  * - `'anthropic'` - Anthropic (Claude 3.5 Sonnet, Claude 3 Opus, etc.)
  * - `'google-gemini'` - Google (Gemini 1.5 Pro, Gemini 2.0 Flash, etc.)
  * - `'azure-openai'` - Azure OpenAI Service
- * - `'groq'` - Groq (Llama, Mixtral with fast inference)
  * - `'cohere'` - Cohere (Command R+, embeddings)
  * - `'mistral'` - Mistral AI (Mistral Large, Codestral)
  * - `'deepseek'` - DeepSeek (DeepSeek-V4-Flash, DeepSeek-V4-Pro)
- * - `'together'` - Together AI (various open models)
- * - `'openrouter'` - OpenRouter (unified API for many providers)
- * - `'ollama'` - Ollama (local models)
  * - `'huggingface'` - Hugging Face Inference API
  * - `'reka'` - Reka AI
  * - `'grok'` - xAI Grok
- * - `'webllm'` - WebLLM (browser-based inference)
  *
  * @param options - Provider-specific configuration. Must include `name` to identify the provider.
  * @param options.name - The provider identifier (see list above)
- * @param options.apiKey - API key for the provider (not needed for Ollama/WebLLM)
+ * @param options.apiKey - API key for the provider
  * @param options.config - Optional default model configuration (maxTokens, temperature, etc.)
  * @param options.models - Optional custom model aliases for type-safe model selection
  *
@@ -8975,11 +8653,13 @@ type InferTModelKey<T> = T extends {
  * // Now use ai with model: 'fast' or model: 'smart'
  * ```
  *
- * @example Local models with Ollama
+ * @example OpenAI-compatible endpoint
  * ```typescript
  * const ai = ai({
- *   name: 'ollama',
- *   config: { model: 'llama3.2' }
+ *   name: 'openai',
+ *   apiKey: process.env.PROVIDER_API_KEY,
+ *   apiURL: 'https://example.com/v1',
+ *   config: { model: 'provider/model-name' }
  * });
  * ```
  */
@@ -8987,23 +8667,7 @@ declare function ai<const T extends AxAIArgs<any>>(options: T): AxAI<InferTModel
 declare class AxAI<TModelKey = string> implements AxAIService<any, any, TModelKey> {
     private ai;
     static create<const T extends AxAIArgs<any>>(options: T): AxAI<InferTModelKey<T>>;
-    /**
-     * @deprecated Use `AxAI.create()` or `ai()` function instead for better type safety.
-     * This constructor will be removed in v15.0.0.
-     *
-     * Migration timeline:
-     * - v13.0.24+: Deprecation warnings (current)
-     * - v14.0.0: Runtime console warnings
-     * - v15.0.0: Complete removal
-     *
-     * @example
-     * ```typescript
-     * // Instead of: new AxAI({ name: 'openai', apiKey: '...' })
-     * // Use: AxAI.create({ name: 'openai', apiKey: '...' })
-     * // Or: ai({ name: 'openai', apiKey: '...' })
-     * ```
-     */
-    constructor(options: Readonly<AxAIArgs<TModelKey>>);
+    private constructor();
     getName(): string;
     getId(): string;
     getFeatures(model?: string): AxAIFeatures;
@@ -9074,11 +8738,6 @@ declare const axModelInfoDeepSeek: AxModelInfo[];
  */
 declare const axModelInfoGoogleGemini: AxModelInfo[];
 
-/**
- * AxAIGroq: Model information
- */
-declare const axModelInfoGroq: AxModelInfo[];
-
 /**
  * HuggingFace: Model information
  */
@@ -9258,28 +8917,6 @@ declare const axModelInfoOpenAI: AxModelInfo[];
  */
 declare const axModelInfoOpenAIResponses: AxModelInfo[];
 
-declare class AxAIOpenAIResponsesImpl<TModel, TEmbedModel, // Kept for interface compatibility, but not used by this impl.
-TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> implements AxAIServiceImpl<TModel, TEmbedModel, Readonly<AxAIOpenAIResponsesRequest<TModel>>, // ChatReq (now ResponsesReq)
-Readonly<AxAIOpenAIEmbedRequest<TEmbedModel>>, // EmbedReq
-Readonly<AxAIOpenAIResponsesResponse>, // ChatResp (now ResponsesResp)
-Readonly<AxAIOpenAIResponsesResponseDelta>, // ChatRespDelta (now ResponsesRespDelta)
-Readonly<AxAIOpenAIEmbedResponse>> {
-    private readonly config;
-    private readonly streamingUsage;
-    private readonly responsesReqUpdater?;
-    private tokensUsed;
-    constructor(config: Readonly<AxAIOpenAIResponsesConfig<TModel, TEmbedModel>>, streamingUsage: boolean, // If /v1/responses supports include_usage for streams
-    responsesReqUpdater?: ResponsesReqUpdater<TModel, TResponsesReq> | undefined);
-    getTokenUsage(): Readonly<AxTokenUsage> | undefined;
-    getModelConfig(): Readonly<AxModelConfig>;
-    private mapInternalContentToResponsesInput;
-    private createResponsesReqInternalInput;
-    createChatReq(req: Readonly<AxInternalChatRequest<TModel>>, config: Readonly<AxAIServiceOptions>): [Readonly<AxAPI>, Readonly<AxAIOpenAIResponsesRequest<TModel>>];
-    createChatResp(resp: Readonly<AxAIOpenAIResponsesResponse>): Readonly<AxChatResponse>;
-    createChatStreamResp: (streamEvent: Readonly<AxAIOpenAIResponsesResponseDelta>, state: object) => Readonly<AxChatResponse>;
-    createEmbedReq(req: Readonly<AxInternalEmbedRequest<TEmbedModel>>): [AxAPI, AxAIOpenAIEmbedRequest<TEmbedModel>];
-}
-
 type OpenAICompatibleUsageDetails = {
     cached_tokens?: number;
     reasoning_tokens?: number;
@@ -9531,8 +9168,6 @@ declare class AxProviderRouter {
     };
 }
 
-declare const axModelInfoTogether: AxModelInfo[];
-
 type AxChatRequestMessage = AxChatRequest['chatPrompt'][number];
 /**
  * Validates a chat request message item to ensure it meets the required criteria
@@ -9547,255 +9182,8 @@ declare function axValidateChatRequestMessage(item: AxChatRequestMessage): void;
  */
 declare function axValidateChatResponseResult(results: Readonly<AxChatResponseResult[]> | Readonly<AxChatResponseResult>): void;
 
-/**
- * WebLLM model information
- * Note: WebLLM runs models locally in the browser, so there are no API costs
- * However, we include context window and capability information
- */
-declare const axModelInfoWebLLM: AxModelInfo[];
-
 declare const axModelInfoGrok: AxModelInfo[];
 
-type AxDBUpsertRequest = {
-    id: string;
-    text?: string;
-    values?: readonly number[];
-    metadata?: Record<string, string>;
-    table: string;
-    namespace?: string;
-};
-type AxDBUpsertResponse = {
-    ids: string[];
-};
-type AxDBQueryRequest = {
-    id?: string;
-    text?: string;
-    values?: readonly number[];
-    table: string;
-    columns?: string[];
-    limit?: number;
-    namespace?: string;
-};
-type AxDBQueryResponse = {
-    matches: {
-        id: string;
-        score: number;
-        metadata?: Record<string, string>;
-        table?: string;
-    }[];
-};
-interface AxDBService extends AxDBQueryService {
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-}
-interface AxDBQueryService {
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
-}
-
-interface AxDBBaseArgs {
-    fetch?: typeof fetch;
-    tracer?: Tracer;
-}
-interface AxDBBaseOpOptions {
-    span?: Span;
-}
-declare class AxDBBase implements AxDBService {
-    protected name: string;
-    protected fetch?: typeof fetch;
-    private tracer?;
-    _upsert?: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert?: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query?: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBQueryResponse>;
-    constructor({ name, fetch, tracer, }: Readonly<AxDBBaseArgs & {
-        name: string;
-    }>);
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(req: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
-}
-
-type AxDBCloudflareOpOptions = AxDBBaseOpOptions;
-interface AxDBCloudflareArgs extends AxDBBaseArgs {
-    name: 'cloudflare';
-    apiKey: string;
-    accountId: string;
-    fetch?: typeof fetch;
-}
-/**
- * Cloudflare: DB Service
- */
-declare class AxDBCloudflare extends AxDBBase {
-    private apiKey;
-    private accountId;
-    constructor({ apiKey, accountId, fetch, tracer, }: Readonly<Omit<AxDBCloudflareArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
-    batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
-    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBQueryResponse>;
-}
-
-type AxDBMemoryOpOptions = AxDBBaseOpOptions;
-interface AxDBMemoryArgs extends AxDBBaseArgs {
-    name: 'memory';
-}
-type AxDBState = Record<string, Record<string, AxDBUpsertRequest>>;
-/**
- * MemoryDB: DB Service
- */
-declare class AxDBMemory extends AxDBBase {
-    private state;
-    constructor({ tracer }?: Readonly<Omit<AxDBMemoryArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query: (req: Readonly<AxDBQueryRequest>, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBQueryResponse>;
-    getDB: () => AxDBState;
-    setDB: (state: AxDBState) => void;
-    clearDB: () => void;
-}
-
-type AxDBPineconeOpOptions = AxDBBaseOpOptions;
-interface AxDBPineconeArgs extends AxDBBaseArgs {
-    name: 'pinecone';
-    apiKey: string;
-    host: string;
-    fetch?: typeof fetch;
-}
-/**
- * Pinecone: DB Service
- */
-declare class AxDBPinecone extends AxDBBase {
-    private apiKey;
-    private apiURL;
-    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBPineconeArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, _update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
-    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBQueryResponse>;
-}
-
-type AxDBWeaviateOpOptions = AxDBBaseOpOptions;
-interface AxDBWeaviateArgs extends AxDBBaseArgs {
-    name: 'weaviate';
-    apiKey: string;
-    host: string;
-    fetch?: typeof fetch;
-}
-/**
- * Weaviate: DB Service
- */
-declare class AxDBWeaviate extends AxDBBase {
-    private apiKey;
-    private apiURL;
-    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBWeaviateArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBQueryResponse>;
-}
-
-type AxDBArgs = AxDBCloudflareArgs | AxDBPineconeArgs | AxDBWeaviateArgs | AxDBMemoryArgs;
-declare class AxDB implements AxDBService {
-    private db;
-    constructor(args: Readonly<AxDBArgs>);
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
-}
-
-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<string>>);
-    forward: <T extends Readonly<AxAIService>>(ai: T, input: Readonly<AxRerankerIn>, options?: Readonly<AxProgramForwardOptionsWithModels<T>>) => Promise<AxRerankerOut>;
-}
-
-interface AxApacheTikaArgs {
-    url?: string | URL;
-    fetch?: typeof fetch;
-}
-interface AxApacheTikaConvertOptions {
-    format?: 'text' | 'html';
-}
-declare class AxApacheTika {
-    private tikaUrl;
-    private fetch?;
-    constructor(args?: Readonly<AxApacheTikaArgs>);
-    private _convert;
-    convert(files: Readonly<Blob[] | ReadableStream[]>, options?: Readonly<{
-        batchSize?: number;
-        format?: 'html' | 'text';
-    }>): Promise<string[]>;
-}
-
-interface AxSimpleClassifierForwardOptions {
-    cutoff?: number;
-    abortSignal?: AbortSignal;
-}
-declare class AxSimpleClassifierClass {
-    private readonly name;
-    private readonly context;
-    constructor(name: string, context: readonly string[]);
-    getName(): string;
-    getContext(): readonly string[];
-}
-declare class AxSimpleClassifier {
-    private readonly ai;
-    private db;
-    private debug?;
-    constructor(ai: AxAIService);
-    getState(): AxDBState | undefined;
-    setState(state: AxDBState): void;
-    setClasses: (classes: readonly AxSimpleClassifierClass[], options?: Readonly<{
-        abortSignal?: AbortSignal;
-    }>) => Promise<void>;
-    forward(text: string, options?: Readonly<AxSimpleClassifierForwardOptions>): Promise<string>;
-    setOptions(options: Readonly<{
-        debug?: boolean;
-    }>): void;
-}
-
 type AxDateRange = {
     start: Date;
     end: Date;
@@ -9871,329 +9259,92 @@ declare const axGlobals: {
     functionResultFormatter: AxFunctionResultFormatter;
 };
 
-/**
- * AxStorage - Persistence layer for traces, checkpoints, and agent state.
- *
- * This module provides a pluggable storage interface that works across
- * different environments (browser, Node.js, cloud).
- */
-/**
- * Represents a single trace event from an AxGen execution.
- */
-/**
- * Represents a single trace event from an AxGen execution.
- */
-interface AxTrace {
-    type: 'trace';
-    /** Unique identifier for this trace */
-    id: string;
-    /** Agent or generator name */
-    name: string;
-    /** Input values passed to forward() */
-    input: Record<string, unknown>;
-    /** Output values from forward() */
-    output: Record<string, unknown>;
-    /** Timestamp when execution started */
-    startTime: Date;
-    /** Timestamp when execution completed */
-    endTime: Date;
-    /** Duration in milliseconds */
-    durationMs: number;
-    /** Model used for generation */
-    model?: string;
-    /** Token usage statistics */
-    usage?: {
-        inputTokens: number;
-        outputTokens: number;
-        totalTokens: number;
-    };
-    /** User feedback if provided */
-    feedback?: {
-        score?: number;
-        label?: string;
-        comment?: string;
-    };
-    /** Error message if execution failed */
-    error?: string;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-}
-type AxLearnCheckpointMode = 'batch' | 'continuous' | 'playbook';
-interface AxLearnCheckpointState {
-    mode: AxLearnCheckpointMode;
-    instruction?: string;
-    baseInstruction?: string;
-    score?: number;
-    continuous?: {
-        feedbackTraceCount?: number;
-        lastUpdateAt?: string;
-    };
-    playbook?: Record<string, unknown>;
-    artifactSummary?: Record<string, unknown>;
-}
-/**
- * Represents a serialized checkpoint of an AxGen configuration.
- */
-interface AxCheckpoint {
-    type: 'checkpoint';
-    /** Agent or generator name */
-    name: string;
-    /** Version number for this checkpoint */
-    version: number;
-    /** Timestamp when checkpoint was created */
-    createdAt: Date;
-    /** Serialized instruction string */
-    instruction?: string;
-    /** Serialized examples/demos */
-    examples?: Array<{
-        input: Record<string, unknown>;
-        output: Record<string, unknown>;
-    }>;
-    /** Optimization score at checkpoint */
-    score?: number;
-    /** Optimization method used */
-    optimizerType?: string;
-    /** Typed AxLearn state, when the checkpoint comes from AxLearn */
-    learnState?: AxLearnCheckpointState;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Query options for retrieving items.
- */
-interface AxStorageQuery {
-    type: 'trace' | 'checkpoint';
-    /** Filter traces after this date */
-    since?: Date;
-    /** Filter traces before this date */
-    until?: Date;
-    /** Maximum number of items to return */
-    limit?: number;
-    /** Offset for pagination */
-    offset?: number;
-    /** Filter by trace ID or checkpoint version */
-    id?: string;
-    version?: number;
-    /** Filter by feedback presence */
-    hasFeedback?: boolean;
-}
-/**
- * Storage interface for AxLearn persistence.
- */
-type AxStorage = {
-    save: (name: string, item: AxTrace | AxCheckpoint) => Promise<void>;
-    load: (name: string, query: AxStorageQuery) => Promise<(AxTrace | AxCheckpoint)[]>;
-};
+declare const axCreateDefaultColorLogger: (output?: (message: string) => void) => AxLoggerFunction;
+declare const axCreateDefaultTextLogger: (output?: (message: string) => void) => AxLoggerFunction;
 
-/**
- * Individual playbook bullet with metadata used for incremental updates.
- * Mirrors the structure described in the ACE paper (Section 3.1).
- */
-interface AxACEBullet extends Record<string, unknown> {
-    id: string;
-    section: string;
-    content: string;
-    helpfulCount: number;
-    harmfulCount: number;
-    createdAt: string;
-    updatedAt: string;
-    tags?: string[];
-    metadata?: Record<string, unknown>;
-}
-/**
- * Aggregated ACE playbook structure grouped by sections.
- */
-interface AxACEPlaybook {
-    version: number;
-    sections: Record<string, AxACEBullet[]>;
-    stats: {
-        bulletCount: number;
-        helpfulCount: number;
-        harmfulCount: number;
-        tokenEstimate: number;
-    };
-    updatedAt: string;
-    description?: string;
-}
-/**
- * Generator output format (Appendix B of the paper) distilled to core fields.
- */
-interface AxACEGeneratorOutput extends Record<string, unknown> {
-    reasoning: string;
-    answer: unknown;
-    bulletIds: string[];
-    trajectory?: string;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Reflection payload, mapping to the Reflector JSON schema in the paper.
- */
-interface AxACEReflectionOutput extends Record<string, unknown> {
-    reasoning: string;
-    errorIdentification: string;
-    rootCauseAnalysis: string;
-    correctApproach: string;
-    keyInsight: string;
-    bulletTags: {
-        id: string;
-        tag: 'helpful' | 'harmful' | 'neutral';
-    }[];
-    metadata?: Record<string, unknown>;
-}
-/**
- * Curator operations emitted as deltas (Section 3.1).
- */
-type AxACECuratorOperationType = 'ADD' | 'UPDATE' | 'REMOVE';
-interface AxACECuratorOperation {
-    type: AxACECuratorOperationType;
-    section: string;
-    bulletId?: string;
-    content?: string;
-    metadata?: Record<string, unknown>;
+interface AxMetricsConfig {
+    enabled: boolean;
+    enabledCategories: ('generation' | 'streaming' | 'functions' | 'errors' | 'performance')[];
+    maxLabelLength: number;
+    samplingRate: number;
 }
-interface AxACECuratorOutput extends Record<string, unknown> {
-    reasoning: string;
-    operations: AxACECuratorOperation[];
-    metadata?: Record<string, unknown>;
+declare const axDefaultMetricsConfig: AxMetricsConfig;
+type AxErrorCategory = 'validation_error' | 'timeout_error' | 'abort_error' | 'network_error' | 'auth_error' | 'rate_limit_error' | 'function_error' | 'parsing_error' | 'unknown_error';
+interface AxGenMetricsInstruments {
+    generationLatencyHistogram?: Histogram;
+    generationRequestsCounter?: Counter;
+    generationErrorsCounter?: Counter;
+    multiStepGenerationsCounter?: Counter;
+    stepsPerGenerationHistogram?: Histogram;
+    maxStepsReachedCounter?: Counter;
+    validationErrorsCounter?: Counter;
+    errorCorrectionAttemptsHistogram?: Histogram;
+    errorCorrectionSuccessCounter?: Counter;
+    errorCorrectionFailureCounter?: Counter;
+    maxRetriesReachedCounter?: Counter;
+    functionsEnabledGenerationsCounter?: Counter;
+    functionCallStepsCounter?: Counter;
+    functionsExecutedPerGenerationHistogram?: Histogram;
+    functionErrorCorrectionCounter?: Counter;
+    fieldProcessorsExecutedCounter?: Counter;
+    streamingFieldProcessorsExecutedCounter?: Counter;
+    streamingGenerationsCounter?: Counter;
+    streamingDeltasEmittedCounter?: Counter;
+    streamingFinalizationLatencyHistogram?: Histogram;
+    samplesGeneratedHistogram?: Histogram;
+    resultPickerUsageCounter?: Counter;
+    resultPickerLatencyHistogram?: Histogram;
+    inputFieldsGauge?: Gauge;
+    outputFieldsGauge?: Gauge;
+    examplesUsedGauge?: Gauge;
+    demosUsedGauge?: Gauge;
+    promptRenderLatencyHistogram?: Histogram;
+    extractionLatencyHistogram?: Histogram;
+    stateCreationLatencyHistogram?: Histogram;
+    memoryUpdateLatencyHistogram?: Histogram;
 }
+declare const axCheckMetricsHealth: () => {
+    healthy: boolean;
+    issues: string[];
+};
+declare const axUpdateMetricsConfig: (config: Readonly<Partial<AxMetricsConfig>>) => void;
+declare const axGetMetricsConfig: () => AxMetricsConfig;
+
 /**
- * Runtime feedback captured after each generator rollout for online updates.
+ * Factory function to create a default optimizer logger with color formatting
  */
-interface AxACEFeedbackEvent {
-    example: AxExample$1;
-    prediction: unknown;
-    score: number;
-    generatorOutput: AxACEGeneratorOutput;
-    reflection?: AxACEReflectionOutput;
-    curator?: AxACECuratorOutput;
-    timestamp: string;
-}
+declare const axCreateDefaultOptimizerColorLogger: (output?: (message: string) => void) => AxOptimizerLoggerFunction;
 /**
- * Configuration options specific to ACE inside Ax.
+ * Factory function to create a text-only optimizer logger (no colors)
  */
-interface AxACEOptions {
-    /**
-     * Maximum number of epochs for offline adaptation.
-     */
-    maxEpochs?: number;
-    /**
-     * Maximum reflector refinement rounds (paper uses up to 5).
-     */
-    maxReflectorRounds?: number;
-    /**
-     * Maximum bullets allowed in any section before triggering pruning.
-     */
-    maxSectionSize?: number;
-    /**
-     * Optional similarity threshold used by the semantic deduper.
-     */
-    similarityThreshold?: number;
-    /**
-     * Whether to automatically create sections when curator emits new ones.
-     */
-    allowDynamicSections?: boolean;
-    /**
-     * Initial playbook supplied by the caller.
-     */
-    initialPlaybook?: AxACEPlaybook;
-}
+declare const axCreateDefaultOptimizerTextLogger: (output?: (message: string) => void) => AxOptimizerLoggerFunction;
 /**
- * Serialized artifact saved after optimization for future reuse.
+ * Default optimizer logger instance with color formatting
  */
-interface AxACEOptimizationArtifact {
-    playbook: AxACEPlaybook;
-    feedback: AxACEFeedbackEvent[];
-    history: {
-        epoch: number;
-        exampleIndex: number;
-        operations: AxACECuratorOperation[];
-    }[];
-}
+declare const axDefaultOptimizerLogger: AxOptimizerLoggerFunction;
 
-interface AxACECompileOptions extends AxCompileOptions {
-    aceOptions?: AxACEOptions;
-}
-interface AxACEResult<OUT extends AxGenOut> extends AxOptimizerResult<OUT> {
-    optimizedProgram?: AxACEOptimizedProgram<OUT>;
-    playbook: AxACEPlaybook;
-    artifact: AxACEOptimizationArtifact;
-}
-/**
- * Optimized program artifact that persists ACE playbook updates.
- */
-declare class AxACEOptimizedProgram<OUT = any> extends AxOptimizedProgramImpl<OUT> {
-    readonly playbook: AxACEPlaybook;
-    readonly artifact: AxACEOptimizationArtifact;
-    private readonly baseInstruction?;
-    constructor(config: {
-        baseInstruction?: string;
-        playbook: AxACEPlaybook;
-        artifact: AxACEOptimizationArtifact;
-        bestScore: number;
-        stats: AxOptimizationStats;
-        optimizerType: string;
-        optimizationTime: number;
-        totalRounds: number;
-        converged: boolean;
-        instruction?: string;
-        demos?: AxOptimizedProgram<OUT>['demos'];
-        examples?: AxExample$1[];
-        modelConfig?: AxOptimizedProgram<OUT>['modelConfig'];
-        scoreHistory?: number[];
-        configurationHistory?: Record<string, unknown>[];
-    });
-    applyTo<IN, T extends AxGenOut>(program: AxGen<IN, T>): void;
-}
-/**
- * AxACE implements the Agentic Context Engineering loop (Generator → Reflector → Curator).
- * The implementation mirrors the paper's architecture while integrating with the Ax optimizer
- * ergonomics (unified optimized program artifacts, metrics, and checkpointing).
- */
-declare class AxACE extends AxBaseOptimizer {
-    private readonly aceConfig;
-    private playbook;
-    private baseInstruction?;
-    private generatorHistory;
-    private deltaHistory;
-    private reflectorProgram?;
-    private curatorProgram?;
-    private program?;
-    constructor(args: Readonly<AxOptimizerArgs>, options?: Readonly<AxACEOptions>);
-    reset(): void;
-    hydrate<IN, OUT extends AxGenOut>(program: Readonly<AxGen<IN, OUT>>, state?: Readonly<{
-        baseInstruction?: string;
-        playbook?: AxACEPlaybook;
-        artifact?: Partial<AxACEOptimizationArtifact>;
-    }>): void;
-    getPlaybook(): AxACEPlaybook;
-    getBaseInstruction(): string | undefined;
-    getArtifact(): AxACEOptimizationArtifact;
-    applyCurrentState<IN, OUT extends AxGenOut>(program?: AxGen<IN, OUT>): void;
-    configureAuto(level: 'light' | 'medium' | 'heavy'): void;
-    compile<IN, OUT extends AxGenOut>(program: Readonly<AxGen<IN, OUT>>, examples: readonly AxTypedExample<IN>[], metricFn: AxMetricFn, options?: AxACECompileOptions): Promise<AxACEResult<OUT>>;
-    /**
-     * Apply ACE updates after each online inference. Mirrors the online adaptation
-     * flow described in the paper; can be called by user-land code between queries.
-     */
-    applyOnlineUpdate(args: Readonly<{
-        example: AxExample$1;
-        prediction: unknown;
-        feedback?: string;
-    }>): Promise<AxACECuratorOutput | undefined>;
-    private composeInstruction;
-    private extractProgramInstruction;
-    private createGeneratorOutput;
-    private resolveCuratorOperationTargets;
-    private locateBullet;
-    private locateFallbackBullet;
-    private collectProtectedBulletIds;
-    private normalizeCuratorOperations;
-    private inferOperationsFromReflection;
-    private runReflectionRounds;
-    private runReflector;
-    private runCurator;
-    private getOrCreateReflectorProgram;
-    private getOrCreateCuratorProgram;
+type AxRolloutTrace<Out = unknown> = {
+    calls: AxFunctionCallTrace[];
+    output?: Out;
+    error?: string;
+};
+
+declare class AxBootstrapFewShot extends AxBaseOptimizer {
+    private maxRounds;
+    private maxDemos;
+    private maxExamples;
+    private batchSize;
+    private earlyStoppingPatience;
+    private costMonitoring;
+    private maxTokensPerGeneration;
+    private verboseMode;
+    private debugMode;
+    private traces;
+    constructor(args: Readonly<AxOptimizerArgs & {
+        options?: AxBootstrapOptimizerOptions;
+    }>);
+    private compileRound;
+    compile<IN, OUT extends AxGenOut>(program: Readonly<AxGen<IN, OUT>>, examples: readonly AxTypedExample<IN>[], metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
 }
 
 /** Structured optimization report */
@@ -10277,6 +9428,193 @@ declare class AxGEPA extends AxBaseOptimizer {
     private mergeInstructions;
 }
 
+type AxGEPABatchRow = {
+    input: AxExample$1;
+    prediction: unknown;
+    scores: Record<string, number>;
+    scalar: number;
+};
+type AxGEPABatchEvaluation = {
+    rows: AxGEPABatchRow[];
+    avg: Record<string, number>;
+    scalars: number[];
+    sum: number;
+    trajectories?: readonly unknown[];
+};
+type AxGEPAEvaluationState = {
+    totalCalls: number;
+    observedScoreKeys: Set<string>;
+};
+
+type AxGEPAReflectiveTuple = {
+    input: AxExample$1;
+    prediction: unknown;
+    score: number;
+};
+type AxGEPATraceSummaryCall = {
+    componentId?: string;
+    fn: string;
+    ok: boolean;
+    ms: number;
+    args: string;
+    result: string;
+};
+type AxGEPATraceSummary = {
+    score: number;
+    calls: AxGEPATraceSummaryCall[];
+    output?: string;
+    error?: string;
+};
+
+type AxRefineStrategy = 'auto' | 'native-samples' | 'serial';
+type AxRewardFnArgs<IN, OUT extends AxGenOut> = {
+    input: Readonly<IN>;
+    prediction: Readonly<OUT>;
+    attempt: number;
+    round: number;
+    sampleIndex: number;
+    traces: readonly AxProgramTrace<IN, OUT>[];
+    chatLog: readonly AxChatLogEntry[];
+};
+type AxRewardFn<IN, OUT extends AxGenOut> = (args: Readonly<AxRewardFnArgs<IN, OUT>>) => number | Promise<number>;
+type AxAttempt<IN, OUT extends AxGenOut> = {
+    attempt: number;
+    round: number;
+    sampleIndex: number;
+    strategy: Exclude<AxRefineStrategy, 'auto'>;
+    input: IN;
+    prediction?: OUT;
+    reward?: number;
+    metThreshold: boolean;
+    traces: AxProgramTrace<IN, OUT>[];
+    chatLog: AxChatLogEntry[];
+    usage: AxProgramUsage[];
+    error?: unknown;
+    advice?: Record<string, string>;
+    adviceApplied?: boolean;
+};
+type AxBestOfNOptions<IN, OUT extends AxGenOut> = {
+    n: number;
+    rewardFn: AxRewardFn<IN, OUT>;
+    threshold?: number;
+    failCount?: number;
+    modelConfig?: Partial<AxModelConfig>;
+    strategy?: AxRefineStrategy;
+    onAttempt?: (attempt: Readonly<AxAttempt<IN, OUT>>) => void | Promise<void>;
+};
+type AxRefineOptions<IN, OUT extends AxGenOut> = {
+    rounds: number;
+    samplesPerRound?: number;
+    rewardFn: AxRewardFn<IN, OUT>;
+    threshold?: number;
+    failCount?: number;
+    modelConfig?: Partial<AxModelConfig>;
+    strategy?: AxRefineStrategy;
+    feedbackAI?: Readonly<AxAIService>;
+    feedbackModelConfig?: Partial<AxModelConfig>;
+    rewardDescription?: string;
+    programDescription?: string;
+    onAttempt?: (attempt: Readonly<AxAttempt<IN, OUT>>) => void | Promise<void>;
+};
+type RunBatchArgs<IN> = {
+    ai: Readonly<AxAIService>;
+    input: IN;
+    forwardOptions?: Readonly<AxProgramForwardOptions<any>>;
+    count: number;
+    round: number;
+    failCount: number;
+    strategy: Exclude<AxRefineStrategy, 'auto'>;
+    threshold?: number;
+};
+declare class AxRefineError extends Error {
+    readonly attempts: readonly AxAttempt<any, any>[];
+    constructor(message: string, attempts?: readonly AxAttempt<any, any>[]);
+}
+declare abstract class AxRefineBase<IN, OUT extends AxGenOut> implements AxProgrammable<IN, OUT> {
+    protected readonly program: Readonly<AxProgrammable<IN, OUT>>;
+    protected abstract readonly modelConfig?: Partial<AxModelConfig>;
+    protected abstract readonly rewardFn: AxRewardFn<IN, OUT>;
+    protected attempts: AxAttempt<IN, OUT>[];
+    protected selectedAttempt?: AxAttempt<IN, OUT>;
+    constructor(program: Readonly<AxProgrammable<IN, OUT>>);
+    abstract forward(ai: Readonly<AxAIService>, input: IN, options?: Readonly<AxProgramForwardOptions<any>>): Promise<OUT>;
+    getAttempts(): readonly AxAttempt<IN, OUT>[];
+    getSignature(): AxSignature;
+    getId(): string;
+    setId(id: string): void;
+    getTraces(): AxProgramTrace<IN, OUT>[];
+    namedProgramInstances(): AxNamedProgramInstance<any, any>[];
+    setDemos(demos: readonly AxProgramDemos<IN, OUT>[], options?: {
+        modelConfig?: Record<string, unknown>;
+    }): void;
+    applyOptimization(optimizedProgram: AxOptimizedProgram<OUT>): void;
+    getOptimizableComponents(): readonly AxOptimizableComponent[];
+    applyOptimizedComponents(updates: Readonly<Record<string, string>>): void;
+    getUsage(): AxProgramUsage[];
+    getChatLog(): readonly AxChatLogEntry[];
+    resetUsage(): void;
+    streamingForward(_ai: Readonly<AxAIService>, _values: IN, _options?: Readonly<AxProgramStreamingForwardOptions<any>>): AxGenStreamingOut<OUT>;
+    protected resetRun(): void;
+    protected emitAttempt(onAttempt: AxBestOfNOptions<IN, OUT>['onAttempt'] | undefined, attempt: AxAttempt<IN, OUT>): Promise<void>;
+    protected runCandidateBatch({ ai, input, forwardOptions, count, round, failCount, strategy, threshold, }: RunBatchArgs<IN>): Promise<AxAttempt<IN, OUT>[]>;
+    private runNativeSampleBatch;
+    private runSerialBatch;
+    protected selectBest(attempts: readonly AxAttempt<IN, OUT>[]): (AxAttempt<IN, OUT> & {
+        prediction: OUT;
+        reward: number;
+    }) | undefined;
+    protected firstThreshold(attempts: readonly AxAttempt<IN, OUT>[]): AxAttempt<IN, OUT> | undefined;
+}
+declare class AxBestOfN<IN, OUT extends AxGenOut> extends AxRefineBase<IN, OUT> {
+    private readonly n;
+    private readonly failCount;
+    private readonly threshold?;
+    private readonly strategy?;
+    protected readonly modelConfig?: Partial<AxModelConfig>;
+    protected readonly rewardFn: AxRewardFn<IN, OUT>;
+    private readonly onAttempt?;
+    constructor(program: Readonly<AxProgrammable<IN, OUT>>, options: Readonly<AxBestOfNOptions<IN, OUT>>);
+    forward(ai: Readonly<AxAIService>, input: IN, options?: Readonly<AxProgramForwardOptions<any>>): Promise<OUT>;
+}
+declare class AxRefine<IN, OUT extends AxGenOut> extends AxRefineBase<IN, OUT> {
+    private readonly rounds;
+    private readonly samplesPerRound;
+    private readonly failCount;
+    private readonly threshold?;
+    private readonly strategy?;
+    protected readonly modelConfig?: Partial<AxModelConfig>;
+    protected readonly rewardFn: AxRewardFn<IN, OUT>;
+    private readonly feedbackAI?;
+    private readonly feedbackModelConfig?;
+    private readonly rewardDescription?;
+    private readonly programDescription?;
+    private readonly onAttempt?;
+    constructor(program: Readonly<AxProgrammable<IN, OUT>>, options: Readonly<AxRefineOptions<IN, OUT>>);
+    forward(ai: Readonly<AxAIService>, input: IN, options?: Readonly<AxProgramForwardOptions<any>>): Promise<OUT>;
+    private captureInstructionComponents;
+    private applyAdvice;
+    private restoreInstructionComponents;
+    private generateAdvice;
+}
+declare function bestOfN<IN, OUT extends AxGenOut>(program: Readonly<AxProgrammable<IN, OUT>>, options: Readonly<AxBestOfNOptions<IN, OUT>>): AxBestOfN<IN, OUT>;
+declare function refine<IN, OUT extends AxGenOut>(program: Readonly<AxProgrammable<IN, OUT>>, options: Readonly<AxRefineOptions<IN, OUT>>): AxRefine<IN, OUT>;
+
+interface AxSamplePickerOptions<OUT> {
+    resultPicker?: AxResultPickerFunction<OUT>;
+}
+
+declare const AxStringUtil: {
+    trimNonAlphaNum: (str: string) => string;
+    splitIntoTwo: (str: string, separator: Readonly<RegExp | string>) => string[];
+    dedup: (seq: readonly string[]) => string[];
+    extractIdAndText: (input: string) => {
+        id: number;
+        text: string;
+    };
+    extractIndexPrefixedText: (input: string) => string;
+    batchArray: <T>(arr: readonly T[], size: number) => T[][];
+};
+
 /**
  * AxSynth - Synthetic data generator for bootstrapping optimization datasets.
  *
@@ -10381,439 +9719,6 @@ declare class AxSynth<IN extends AxGenIn, OUT extends AxGenOut> {
     getTeacher(): AxAIService;
 }
 
-/**
- * AxLearn - Self-improving agent that learns from traces and feedback.
- *
- * Combines AxGen with automatic trace logging, storage, and mode-based
- * optimization/update flows.
- */
-
-type AxLearnMode = AxLearnCheckpointMode;
-type AxLearnPlaybook = AxACEPlaybook;
-interface AxLearnContinuousOptions {
-    feedbackWindowSize?: number;
-    maxRecentTraces?: number;
-    updateBudget?: number;
-}
-type AxLearnPlaybookOptions = Partial<AxACEOptions>;
-/**
- * Configuration for the AxLearn agent.
- */
-interface AxLearnOptions {
-    /** Unique identifier/name for this agent */
-    name: string;
-    /** Storage backend (Required) */
-    storage: AxStorage;
-    /** Runtime model whose outputs should be improved */
-    runtimeAI?: AxAIService;
-    /** Learning mode (default: batch) */
-    mode?: AxLearnMode;
-    /** Whether to log traces (default: true) */
-    enableTracing?: boolean;
-    /** Custom metadata for all traces */
-    metadata?: Record<string, unknown>;
-    /** Callback when a trace is logged */
-    onTrace?: (trace: AxTrace) => void;
-    /** Teacher AI for synthetic data generation and judging (Required) */
-    teacher: AxAIService;
-    /** Maximum optimization rounds (default: 20) */
-    budget?: number;
-    /** Custom metric function (if not provided, auto-generates using typed AxGen evaluation) */
-    metric?: AxMetricFn;
-    /** Judge options when auto-generating metric */
-    judgeOptions?: Partial<AxJudgeOptions>;
-    /** Custom evaluation criteria for judge */
-    criteria?: string;
-    /** Training examples (manual) */
-    examples?: AxTypedExample<AxGenIn>[];
-    /** Whether to use captured traces as training examples (default: true) */
-    useTraces?: boolean;
-    /** Whether to generate synthetic examples (default: true if no other data) */
-    generateExamples?: boolean;
-    /** Number of synthetic examples to generate */
-    synthCount?: number;
-    /** Synth options for data generation */
-    synthOptions?: Partial<AxSynthOptions>;
-    /** Validation split ratio (default: 0.2, clamped to keep train + validation non-empty) */
-    validationSplit?: number;
-    /** Mode-specific configuration for bounded continuous updates */
-    continuousOptions?: AxLearnContinuousOptions;
-    /** Mode-specific configuration for playbook learning */
-    playbookOptions?: AxLearnPlaybookOptions;
-    /** Progress callback */
-    onProgress?: (progress: AxLearnProgress) => void;
-}
-interface AxLearnOptimizeOptions {
-    runtimeAI?: AxAIService;
-    budget?: number;
-    metric?: AxMetricFn;
-    judgeOptions?: Partial<AxJudgeOptions>;
-    criteria?: string;
-    examples?: AxTypedExample<AxGenIn>[];
-    useTraces?: boolean;
-    generateExamples?: boolean;
-    synthCount?: number;
-    synthOptions?: Partial<AxSynthOptions>;
-    validationSplit?: number;
-    continuousOptions?: AxLearnContinuousOptions;
-    playbookOptions?: AxLearnPlaybookOptions;
-    onProgress?: (progress: AxLearnProgress) => void;
-}
-type AxLearnUpdateFeedback = string | NonNullable<AxTrace['feedback']>;
-interface AxLearnUpdateInput<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> {
-    example: AxTypedExample<IN>;
-    prediction: OUT;
-    feedback?: AxLearnUpdateFeedback;
-}
-interface AxLearnUpdateOptions {
-    runtimeAI?: AxAIService;
-    budget?: number;
-    metric?: AxMetricFn;
-    judgeOptions?: Partial<AxJudgeOptions>;
-    criteria?: string;
-    continuousOptions?: AxLearnContinuousOptions;
-    playbookOptions?: AxLearnPlaybookOptions;
-    onProgress?: (progress: AxLearnProgress) => void;
-}
-interface AxLearnPlaybookSummary {
-    feedbackEvents: number;
-    historyBatches: number;
-    bulletCount: number;
-    updatedAt?: string;
-}
-interface AxLearnArtifact {
-    playbook?: AxLearnPlaybook;
-    playbookSummary?: AxLearnPlaybookSummary;
-    lastUpdateAt?: string;
-    feedbackExamples?: number;
-}
-/**
- * Progress callback for monitoring optimization.
- */
-interface AxLearnProgress {
-    round: number;
-    totalRounds: number;
-    score: number;
-    improvement: number;
-}
-/**
- * Result from optimize/applyUpdate operations.
- */
-interface AxLearnResult<_IN extends AxGenIn, _OUT extends AxGenOut> {
-    mode: AxLearnMode;
-    score: number;
-    improvement: number;
-    checkpointVersion: number;
-    stats: {
-        trainingExamples: number;
-        validationExamples: number;
-        feedbackExamples: number;
-        durationMs: number;
-        mode: AxLearnMode;
-    };
-    state?: AxLearnCheckpointState;
-    artifact?: AxLearnArtifact;
-}
-type AxLearnMergedConfig = {
-    runtimeAI?: AxAIService;
-    mode: AxLearnMode;
-    teacher: AxAIService;
-    budget: number;
-    metric?: AxMetricFn;
-    judgeOptions?: Partial<AxJudgeOptions>;
-    criteria?: string;
-    examples?: AxTypedExample<AxGenIn>[];
-    useTraces: boolean;
-    generateExamples: boolean;
-    synthCount?: number;
-    synthOptions?: Partial<AxSynthOptions>;
-    validationSplit: number;
-    continuousOptions: Required<AxLearnContinuousOptions>;
-    playbookOptions?: AxLearnPlaybookOptions;
-    onProgress?: (progress: AxLearnProgress) => void;
-};
-/**
- * AxLearn wraps an AxGen with automatic trace logging and self-improvement capabilities.
- */
-declare class AxLearn<IN extends AxGenIn, OUT extends AxGenOut> implements AxForwardable<IN, OUT, string>, AxUsable {
-    private gen;
-    private options;
-    private tracer;
-    private currentScore?;
-    private currentState?;
-    private readyPromise;
-    private playbookOptimizer?;
-    constructor(gen: AxGen<IN, OUT>, options: AxLearnOptions);
-    ready(): Promise<void>;
-    /**
-     * Forward call - behaves like AxGen.forward() but waits for restore and logs traces.
-     */
-    forward(ai: AxAIService, values: IN, options?: Readonly<AxProgramForwardOptions<string>>): Promise<OUT>;
-    /**
-     * Streaming forward call - behaves like AxGen.streamingForward() but waits for restore and logs traces.
-     */
-    streamingForward(ai: AxAIService, values: IN, options?: Readonly<AxProgramForwardOptions<string>>): AxGenStreamingOut<OUT>;
-    getUsage(): AxProgramUsage[];
-    getChatLog(): readonly AxChatLogEntry[];
-    resetUsage(): void;
-    getSignature(): AxSignature;
-    setInstruction(instruction: string): void;
-    getInstruction(): string | undefined;
-    updateMeter(meter?: Meter): void;
-    addAssert(fn: AxAssertion<OUT>['fn'], message?: string): void;
-    addStreamingAssert(fieldName: keyof OUT, fn: AxStreamingAssertion['fn'], message?: string): void;
-    addFieldProcessor(fieldName: keyof OUT, fn: (value: OUT[keyof OUT], context?: {
-        values?: OUT;
-        sessionId?: string;
-        done?: boolean;
-    }) => unknown | Promise<unknown>): void;
-    addStreamingFieldProcessor(fieldName: keyof OUT, fn: (value: string, context?: {
-        values?: OUT;
-        sessionId?: string;
-        done?: boolean;
-    }) => unknown | Promise<unknown>): void;
-    clone(): AxLearn<IN, OUT>;
-    /**
-     * Run the configured learning flow for the current mode.
-     */
-    optimize(overrides?: AxLearnOptimizeOptions): Promise<AxLearnResult<IN, OUT>>;
-    /**
-     * Apply a bounded online update for continuous/playbook modes.
-     */
-    applyUpdate(input: Readonly<AxLearnUpdateInput<IN, OUT>>, overrides?: AxLearnUpdateOptions): Promise<AxLearnResult<IN, OUT>>;
-    /**
-     * Get the underlying AxGen instance.
-     */
-    getGen(): AxGen<IN, OUT>;
-    /**
-     * Get the storage backend.
-     */
-    getStorage(): AxStorage;
-    /**
-     * Get recent traces for this agent.
-     */
-    getTraces(options?: {
-        limit?: number;
-        since?: Date;
-    }): Promise<AxTrace[]>;
-    /**
-     * Add feedback to a specific trace.
-     */
-    addFeedback(traceId: string, feedback: NonNullable<AxTrace['feedback']>): Promise<void>;
-    protected createPromptOptimizer(config: Readonly<AxLearnMergedConfig>, baselineScore: number): AxGEPA;
-    protected createPlaybookOptimizer(config: Readonly<AxLearnMergedConfig>, baselineScore: number): AxACE;
-    private mergeConfig;
-    private requireRuntimeAI;
-    private createOptimizerProgressHandler;
-    private resolveMetric;
-    private runPromptOptimization;
-    private optimizePlaybook;
-    private applyPlaybookUpdate;
-    private getOrCreatePlaybookOptimizer;
-    private prepareDataset;
-    private loadRelevantTraces;
-    private normalizeExample;
-    private buildObservedUpdateExample;
-    private pickInputFields;
-    private pickOutputFields;
-    private hasInputFields;
-    private hasOutputFields;
-    private exampleKey;
-    private feedbackToText;
-    private formatObservedUpdateFeedback;
-    private splitExamples;
-    private shuffleExamples;
-    private computeMetricBudget;
-    private createPromptState;
-    private createPlaybookState;
-    private summarizePlaybookArtifact;
-    private saveCheckpoint;
-    private loadLatestCheckpoint;
-    private applyRestoredPlaybook;
-}
-
-type AxDataRow = {
-    row: Record<string, AxFieldValue>;
-};
-declare class AxHFDataLoader {
-    private rows;
-    private baseUrl;
-    private dataset;
-    private split;
-    private config;
-    private options?;
-    constructor({ dataset, split, config, options, }: Readonly<{
-        dataset: string;
-        split: string;
-        config: string;
-        options?: Readonly<{
-            offset?: number;
-            length?: number;
-        }>;
-    }>);
-    private fetchDataFromAPI;
-    loadData(): Promise<AxDataRow[]>;
-    setData(rows: AxDataRow[]): void;
-    getData(): AxDataRow[];
-    getRows<T>({ count, fields, renameMap, }: Readonly<{
-        count: number;
-        fields: readonly string[];
-        renameMap?: Record<string, string>;
-    }>): Promise<T[]>;
-}
-
-declare const axCreateDefaultColorLogger: (output?: (message: string) => void) => AxLoggerFunction;
-declare const axCreateDefaultTextLogger: (output?: (message: string) => void) => AxLoggerFunction;
-
-interface AxMetricsConfig {
-    enabled: boolean;
-    enabledCategories: ('generation' | 'streaming' | 'functions' | 'errors' | 'performance')[];
-    maxLabelLength: number;
-    samplingRate: number;
-}
-declare const axDefaultMetricsConfig: AxMetricsConfig;
-type AxErrorCategory = 'validation_error' | 'assertion_error' | 'timeout_error' | 'abort_error' | 'network_error' | 'auth_error' | 'rate_limit_error' | 'function_error' | 'parsing_error' | 'unknown_error';
-interface AxGenMetricsInstruments {
-    generationLatencyHistogram?: Histogram;
-    generationRequestsCounter?: Counter;
-    generationErrorsCounter?: Counter;
-    multiStepGenerationsCounter?: Counter;
-    stepsPerGenerationHistogram?: Histogram;
-    maxStepsReachedCounter?: Counter;
-    validationErrorsCounter?: Counter;
-    assertionErrorsCounter?: Counter;
-    errorCorrectionAttemptsHistogram?: Histogram;
-    errorCorrectionSuccessCounter?: Counter;
-    errorCorrectionFailureCounter?: Counter;
-    maxRetriesReachedCounter?: Counter;
-    functionsEnabledGenerationsCounter?: Counter;
-    functionCallStepsCounter?: Counter;
-    functionsExecutedPerGenerationHistogram?: Histogram;
-    functionErrorCorrectionCounter?: Counter;
-    fieldProcessorsExecutedCounter?: Counter;
-    streamingFieldProcessorsExecutedCounter?: Counter;
-    streamingGenerationsCounter?: Counter;
-    streamingDeltasEmittedCounter?: Counter;
-    streamingFinalizationLatencyHistogram?: Histogram;
-    samplesGeneratedHistogram?: Histogram;
-    resultPickerUsageCounter?: Counter;
-    resultPickerLatencyHistogram?: Histogram;
-    inputFieldsGauge?: Gauge;
-    outputFieldsGauge?: Gauge;
-    examplesUsedGauge?: Gauge;
-    demosUsedGauge?: Gauge;
-    promptRenderLatencyHistogram?: Histogram;
-    extractionLatencyHistogram?: Histogram;
-    assertionLatencyHistogram?: Histogram;
-    stateCreationLatencyHistogram?: Histogram;
-    memoryUpdateLatencyHistogram?: Histogram;
-}
-declare const axCheckMetricsHealth: () => {
-    healthy: boolean;
-    issues: string[];
-};
-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;
-
-type AxRolloutTrace<Out = unknown> = {
-    calls: AxFunctionCallTrace[];
-    output?: Out;
-    error?: string;
-};
-
-declare class AxBootstrapFewShot extends AxBaseOptimizer {
-    private maxRounds;
-    private maxDemos;
-    private maxExamples;
-    private batchSize;
-    private earlyStoppingPatience;
-    private costMonitoring;
-    private maxTokensPerGeneration;
-    private verboseMode;
-    private debugMode;
-    private traces;
-    constructor(args: Readonly<AxOptimizerArgs & {
-        options?: AxBootstrapOptimizerOptions;
-    }>);
-    private compileRound;
-    compile<IN, OUT extends AxGenOut>(program: Readonly<AxGen<IN, OUT>>, examples: readonly AxTypedExample<IN>[], metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxOptimizerResult<OUT>>;
-}
-
-type AxGEPABatchRow = {
-    input: AxExample$1;
-    prediction: unknown;
-    scores: Record<string, number>;
-    scalar: number;
-};
-type AxGEPABatchEvaluation = {
-    rows: AxGEPABatchRow[];
-    avg: Record<string, number>;
-    scalars: number[];
-    sum: number;
-    trajectories?: readonly unknown[];
-};
-type AxGEPAEvaluationState = {
-    totalCalls: number;
-    observedScoreKeys: Set<string>;
-};
-
-type AxGEPAReflectiveTuple = {
-    input: AxExample$1;
-    prediction: unknown;
-    score: number;
-};
-type AxGEPATraceSummaryCall = {
-    componentId?: string;
-    fn: string;
-    ok: boolean;
-    ms: number;
-    args: string;
-    result: string;
-};
-type AxGEPATraceSummary = {
-    score: number;
-    calls: AxGEPATraceSummaryCall[];
-    output?: string;
-    error?: string;
-};
-
-type AxInstanceRegistryItem<T extends AxTunable<IN, OUT>, IN, OUT> = T & AxUsable;
-declare class AxInstanceRegistry<T extends AxTunable<IN, OUT>, IN, OUT> {
-    private reg;
-    constructor();
-    register(instance: AxInstanceRegistryItem<T, IN, OUT>): void;
-    [Symbol.iterator](): Generator<AxInstanceRegistryItem<T, IN, OUT>, void, unknown>;
-}
-
-interface AxSamplePickerOptions<OUT> {
-    resultPicker?: AxResultPickerFunction<OUT>;
-}
-
-declare const AxStringUtil: {
-    trimNonAlphaNum: (str: string) => string;
-    splitIntoTwo: (str: string, separator: Readonly<RegExp | string>) => string[];
-    dedup: (seq: readonly string[]) => string[];
-    extractIdAndText: (input: string) => {
-        id: number;
-        text: string;
-    };
-    extractIndexPrefixedText: (input: string) => string;
-    batchArray: <T>(arr: readonly T[], size: number) => T[][];
-};
-
 /**
  * Creates a type-safe signature from a string template.
  *
@@ -10931,101 +9836,31 @@ declare function ax<TInput extends Record<string, any>, TOutput extends Record<s
 })>;
 declare function ax(signature: Readonly<AxSignatureConfig>, options?: Readonly<AxProgramForwardOptions<any>>): AxGen<AxGenIn, AxGenOut>;
 
-/**
- * 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
+/**
+ * Best-effort static dependency extraction for flow execute mappings.
  *
- * This dual approach ensures robust dependency detection even for complex
- * mapping functions that might use destructuring, computed property access,
- * or other advanced JavaScript patterns.
+ * This intentionally never invokes user code. It only recognizes direct state
+ * reads that are safe to recognize from function source. Unknown state access is
+ * marked unsafe so the planner can keep execution sequential.
  */
-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;
+interface AxFlowStateDependencyAnalysis {
+    dependencies: string[];
+    isSafe: boolean;
 }
 
 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<string>;
-}>) => Promise<AxFlowState> | AxFlowState;
+interface AxFlowOptions {
+    autoParallel?: boolean;
+    batchSize?: number;
+    logger?: AxFlowLoggerFunction;
+    debug?: boolean;
+    tracer?: Tracer;
+    meter?: Meter;
+}
+type AxFlowForwardOptions<T extends Readonly<AxAIService>> = AxProgramForwardOptionsWithModels<T> & {
+    autoParallel?: boolean;
+    abortController?: AbortController;
+};
 interface AxFlowDynamicContext<T extends Readonly<AxAIService>> {
     ai?: T;
     options?: AxProgramForwardOptions<NonNullable<ReturnType<T['getModelList']>>[number]['key']>;
@@ -11050,257 +9885,27 @@ interface AxFlowTypedSubContext<TNodes extends Record<string, AxProgrammable<any
     executeSteps(initialState: TState, context: Readonly<{
         mainAi: AxAIService;
         mainOptions?: AxProgramForwardOptions<string>;
+        executeSteps?: (steps: readonly unknown[], initialState: AxFlowState) => Promise<AxFlowState>;
     }>): Promise<AxFlowState>;
 }
-type AxFlowParallelBranch = (subFlow: AxFlowSubContext) => AxFlowSubContext;
-interface AxFlowSubContext {
-    execute<TAI extends Readonly<AxAIService>>(nodeName: string, mapping: (state: AxFlowState) => Record<string, AxFieldValue>, dynamicContext?: AxFlowDynamicContext<TAI>): this;
-    map(transform: (state: AxFlowState) => AxFlowState): this;
-    executeSteps<TAI extends Readonly<AxAIService>>(initialState: AxFlowState, context: Readonly<{
-        mainAi: TAI;
-        mainOptions?: AxProgramForwardOptions<NonNullable<ReturnType<TAI['getModelList']>>[number]['key']>;
-    }>): Promise<AxFlowState>;
-}
-interface AxFlowBranchContext {
-    predicate: (state: AxFlowState) => unknown;
-    branches: Map<unknown, AxFlowStepFunction[]>;
-    currentBranchValue?: unknown;
-}
-interface AxFlowExecutionStep {
-    type: 'execute' | 'map' | 'merge' | 'parallel-map' | 'parallel' | 'derive';
+interface AxFlowExecutionPlanStep {
+    type: 'execute' | 'map' | 'returns' | 'branch' | 'while' | 'feedback' | 'parallel' | 'parallelMerge' | 'derive';
     nodeName?: string;
     dependencies: string[];
     produces: string[];
-    stepFunction: AxFlowStepFunction;
     stepIndex: number;
+    isBarrier: boolean;
 }
-interface AxFlowParallelGroup {
+interface AxFlowExecutionPlanGroup {
     level: number;
-    steps: AxFlowExecutionStep[];
-}
-interface AxFlowAutoParallelConfig {
-    enabled: boolean;
-    batchSize?: number;
+    steps: AxFlowExecutionPlanStep[];
 }
-
-/**
- * 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' | 'derive', mapTransform?: (state: any) => any, mergeOptions?: {
-        resultKey?: string;
-        mergeFunction?: (...args: any[]) => any;
-    }, deriveOptions?: {
-        inputFieldName: string;
-        outputFieldName: string;
-        batchSize?: number;
-    }): void;
-    /**
-     * Analyzes a step function to determine what fields it produces.
-     *
-     * This method analyzes the step function to understand what new fields
-     * it adds to the state. It uses a mock state approach:
-     * 1. Creates a mock state with sample data
-     * 2. Runs the step function on the mock state
-     * 3. Compares the result to see what fields were added
-     *
-     * @param stepFunction - The step function to analyze
-     * @returns Array of field names that the step function produces
-     */
-    private analyzeStepFunctionProduction;
-    /**
-     * Analyzes step function source code to determine what fields it produces.
-     *
-     * @param stepFunction - The step function to analyze
-     * @returns Array of field names that the step function produces
-     */
-    private analyzeStepFunctionSource;
-    /**
-     * 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[];
-    };
+interface AxFlowExecutionPlan {
+    totalSteps: number;
+    parallelGroups: number;
+    maxParallelism: number;
+    steps: AxFlowExecutionPlanStep[];
+    groups: AxFlowExecutionPlanGroup[];
 }
 
 /**
@@ -11389,114 +9994,37 @@ declare const axCreateFlowTextLogger: (output?: (message: string) => void) => Ax
  */
 declare const axDefaultFlowLogger: AxFlowLoggerFunction;
 
-/**
- * AxFlow - A fluent, chainable API for building and orchestrating complex, stateful AI programs.
- *
- * Now with advanced type-safe chaining where each method call evolves the type information,
- * providing compile-time type safety and superior IntelliSense.
- *
- * @example
- * ```
- * const flow = new AxFlow<{ topic: string }, { finalAnswer: string }>()
- *   .node('summarizer', 'text:string -> summary:string')
- *   .node('critic', 'summary:string -> critique:string')
- *   .execute('summarizer', state => ({ text: `About ${state.topic}` })) // state is { topic: string }
- *   .execute('critic', state => ({ summary: state.summarizerResult.summary })) // state evolves!
- *   .map(state => ({ finalAnswer: state.criticResult.critique })) // fully typed!
- *
- * const result = await flow.forward(ai, { topic: "AI safety" })
- * ```
- */
-declare class AxFlow<IN extends Record<string, any>, OUT, TNodes extends Record<string, AxProgrammable<any, any>> = {}, // Node registry for type tracking
-TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
-    private static _ctorWarned;
-    private static _constructingFromFactory;
-    private readonly nodes;
-    private readonly flowDefinition;
+interface AxFlowNodeExecutionRecorder {
+    recordUsage(nodeName: string, usage: AxProgramUsage[]): void;
+    recordTraces(nodeName: string, traces: AxProgramTrace<any, any>[]): void;
+    recordChatLog(nodeName: string, entries: AxChatLogEntry[]): void;
+}
+
+declare class AxFlow<IN extends Record<string, any>, OUT, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, TState extends AxFlowState = IN> implements AxFlowable<IN, OUT>, AxFlowNodeExecutionRecorder {
+    private readonly steps;
+    private currentSteps;
     private readonly nodeGenerators;
-    private readonly loopStack;
     private readonly stepLabels;
+    private readonly loopStack;
     private branchContext;
-    private readonly autoParallelConfig;
-    private readonly executionPlanner;
     private program?;
     private flowName?;
-    private nodeUsage;
-    private nodeTraces;
-    private nodeChatLog;
+    private readonly autoParallelConfig;
     private readonly flowLogger?;
     private readonly timingLogger?;
     private readonly defaultAIOptions?;
+    private nodeUsage;
+    private nodeTraces;
+    private nodeChatLog;
     private activeAbortControllers;
     private _stopRequested;
-    /**
-     * Converts a string to camelCase for valid field names
-     */
+    private constructor();
+    static create<IN extends Record<string, any> = Record<string, unknown>, OUT = {}, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, TState extends AxFlowState = IN>(options?: AxFlowOptions): AxFlow<IN, OUT, TNodes, TState>;
     private toCamelCase;
-    /**
-     * Stops an in-flight `forward()` call. Causes it to throw
-     * `AxAIServiceAbortedError`.
-     */
     stop(): void;
+    private addStep;
     private getCacheKey;
-    /**
-     * Executes a list of steps with comprehensive logging
-     */
-    private executeStepsWithLogging;
-    /**
-     * Determines the type of a step function for logging purposes
-     */
-    private getStepType;
-    /**
-     * Gets metadata about a step for logging purposes
-     */
-    private getStepMetadata;
-    /**
-     * Extracts node name from step function source code
-     */
-    private extractNodeNameFromSource;
-    /**
-     * 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;
-        logger?: AxFlowLoggerFunction;
-        debug?: boolean;
-        tracer?: Tracer;
-        meter?: Meter;
-    });
-    /**
-     * Static factory method to create a new AxFlow instance with proper type safety
-     * @param options - Optional configuration for the flow
-     * @returns New AxFlow instance with type-safe defaults
-     */
-    static create<IN extends Record<string, any> = Record<string, never>, OUT = {}, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, TState extends AxFlowState = IN>(options?: {
-        autoParallel?: boolean;
-        batchSize?: number;
-        logger?: AxFlowLoggerFunction;
-        debug?: boolean;
-    }): AxFlow<IN, OUT, TNodes, TState>;
-    /**
-     * Initializes the program field every time something is  added to the graph
-     */
     private ensureProgram;
     getId(): string;
     setId(id: string): void;
@@ -11514,150 +10042,33 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     getUsage(): AxProgramUsage[];
     getChatLog(): readonly AxChatLogEntry[];
     resetUsage(): void;
-    /**
-     * Resets trace tracking for the flow.
-     * This is called automatically on each forward/streamingForward call.
-     */
     resetTraces(): void;
     resetChatLog(): void;
-    /**
-     * Gets a detailed usage report broken down by node name.
-     * This provides visibility into which nodes are consuming the most tokens.
-     *
-     * @returns Object mapping node names to their usage statistics
-     */
     getUsageReport(): Record<string, AxProgramUsage[]>;
-    /**
-     * Expose node programs for system-level operations (optimization, inspection)
-     */
     getNodePrograms(): ReadonlyArray<{
         name: string;
         program: AxProgrammable<any, any>;
     }>;
-    /**
-     * Attempt to set instruction on a node if supported (AxGen.
-     * setInstruction is optional; returns true if applied)
-     */
     setNodeInstruction(name: string, instruction: string): boolean;
-    /**
-     * Bulk-apply instructions to nodes; ignores names that don’t exist or nodes without instruction setter
-     */
     setAllNodeInstructions(map: Readonly<Record<string, string>>): void;
-    /**
-     * Gets a detailed trace report broken down by node name.
-     * This provides visibility into the execution traces for each node.
-     *
-     * @returns Object mapping node names to their trace data
-     */
     getTracesReport(): Record<string, AxProgramTrace<any, any>[]>;
-    streamingForward<T extends Readonly<AxAIService>>(ai: T, values: IN, options?: Readonly<AxProgramStreamingForwardOptionsWithModels<T> & {
-        abortController?: AbortController;
-    }>): 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<T extends Readonly<AxAIService>>(ai: T, values: IN, options?: Readonly<AxProgramForwardOptionsWithModels<T> & {
-        autoParallel?: boolean;
-        abortController?: AbortController;
-    }>): Promise<OUT>;
-    /**
-     * Declares a reusable computational node using a signature string.
-     * Returns a new AxFlow type that tracks this node in the TNodes registry.
-     *
-     * @param name - The name of the node
-     * @param signature - Signature string in the same format as AxSignature
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```
-     * flow.node('summarizer', 'text:string -> summary:string')
-     * flow.node('analyzer', 'text:string -> analysis:string, confidence:number', { debug: true })
-     * ```
-     */
+    recordUsage(nodeName: string, usage: AxProgramUsage[]): void;
+    recordTraces(nodeName: string, traces: AxProgramTrace<any, any>[]): void;
+    recordChatLog(_nodeName: string, entries: AxChatLogEntry[]): void;
+    streamingForward<T extends Readonly<AxAIService>>(ai: T, values: IN, options?: Readonly<AxProgramStreamingForwardOptionsWithModels<T>>): AxGenStreamingOut<OUT>;
+    forward<T extends Readonly<AxAIService>>(ai: T, values: IN, options?: Readonly<AxFlowForwardOptions<T>>): Promise<OUT>;
     node<TName extends string, TSig extends string>(name: TName, signature: TSig): AxFlow<IN, OUT, TNodes & {
         [K in TName]: InferAxGen<TSig>;
-    }, // Add new node to registry
-    TState>;
-    /**
-     * Declares a reusable computational node using an AxSignature instance.
-     * This allows using pre-configured signatures in the flow.
-     *
-     * @param name - The name of the node
-     * @param signature - AxSignature instance to use for this node
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```
-     * const sig = s('text:string -> summary:string')
-     * flow.node('summarizer', sig, { temperature: 0.1 })
-     * ```
-     */
+    }, TState>;
     node<TName extends string>(name: TName, signature: AxSignature): AxFlow<IN, OUT, TNodes & {
         [K in TName]: AxGen<AxGenIn, AxGenOut>;
-    }, // Add new node to registry
-    TState>;
-    /**
-     * Declares a reusable computational node using a class that extends AxProgram.
-     * This allows using custom program classes in the flow.
-     *
-     * @param name - The name of the node
-     * @param programClass - Class that extends AxProgram to use for this node
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```
-     * class CustomProgram extends AxProgram<{ input: string }, { output: string }> {
-     *   async forward(ai, values) { return { output: values.input.toUpperCase() } }
-     * }
-     * flow.node('custom', CustomProgram)
-     * ```
-     */
+    }, TState>;
     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
-     */
+    }, TState>;
     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
-     */
+    }, TState>;
     n<TName extends string, TSig extends string>(name: TName, signature: TSig): AxFlow<IN, OUT, TNodes & {
         [K in TName]: InferAxGen<TSig>;
     }, TState>;
@@ -11670,84 +10081,17 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     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.
-     *
-     * @param transform - Function that takes the current state and returns a new state
-     * @returns New AxFlow instance with updated TState type
-     *
-     * @example
-     * ```
-     * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
-     * ```
-     */
     map<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Applies an asynchronous transformation to the state object.
-     * Returns a new AxFlow type with the evolved state.
-     *
-     * @param transform - Async function that takes the current state and returns a promise of new state
-     * @returns New AxFlow instance with updated TState type
-     *
-     * @example
-     * ```
-     * flow.map(async state => ({
-     *   ...state,
-     *   apiResult: await fetchDataFromAPI(state.query)
-     * }))
-     * ```
-     */
     map<TNewState extends AxFlowState>(transform: (_state: TState) => Promise<TNewState>): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * 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
-     * ```
-     * // 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 })
-     * ```
-     */
     map<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => TNewState>, options: {
         parallel: true;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Applies async transformations to the state object with optional parallel execution.
-     * When parallel is enabled, all async transforms are executed concurrently.
-     *
-     * @param transforms - Array of async transformation functions to apply in parallel
-     * @param options - Options including parallel execution configuration
-     * @returns New AxFlow instance with updated TState type
-     *
-     * @example
-     * ```
-     * // Parallel async map with multiple transforms
-     * flow.map([
-     *   async state => ({ ...state, result1: await apiCall1(state.data) }),
-     *   async state => ({ ...state, result2: await apiCall2(state.data) }),
-     *   async state => ({ ...state, result3: await apiCall3(state.data) })
-     * ], { parallel: true })
-     * ```
-     */
     map<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => Promise<TNewState>>, options: {
         parallel: true;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
     map<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState | Promise<TNewState>, options?: {
         parallel?: boolean;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Short alias for map() - supports parallel option and async functions
-     */
     m<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
     m<TNewState extends AxFlowState>(transform: (_state: TState) => Promise<TNewState>): AxFlow<IN, OUT, TNodes, TNewState>;
     m<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => TNewState>, options: {
@@ -11756,298 +10100,50 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     m<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => Promise<TNewState>>, options: {
         parallel: true;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Terminal transformation that sets the final output type of the flow.
-     * Use this as the last transformation to get proper type inference for the flow result.
-     *
-     * @param transform - Function that transforms the current state to the final output
-     * @returns A new flow with the output type set to the transform result
-     *
-     * @example
-     * ```typescript
-     * const flow = flow<{ input: string }>()
-     *   .map(state => ({ ...state, processed: true }))
-     *   .returns(state => ({
-     *     result: state.processed ? "done" : "pending"
-     *   })) // TypeScript now knows the output is { result: string }
-     * ```
-     */
     returns<TNewOut extends Record<string, unknown>>(transform: (_state: TState) => TNewOut): AxFlow<IN, TNewOut, TNodes, TState>;
-    /**
-     * Short alias for returns() - r() is to returns() as m() is to map()
-     *
-     * @param transform - Function that transforms the current state to the final output
-     * @returns A new flow with the output type set to the transform result
-     */
     r<TNewOut extends Record<string, unknown>>(transform: (_state: TState) => TNewOut): AxFlow<IN, TNewOut, TNodes, TState>;
-    /**
-     * Labels a step for later reference (useful for feedback loops).
-     *
-     * @param label - The label to assign to the current step position
-     * @returns this (for chaining, no type change)
-     *
-     * @example
-     * ```typescript
-     * flow.label('retry-point')
-     *   .execute('queryGen', ...)
-     * ```
-     */
     label(label: string): this;
-    /**
-     * Short alias for label()
-     */
     l(label: string): this;
-    /**
-     * Executes a previously defined node with full type safety.
-     * The node name must exist in TNodes, and the mapping function is typed based on the node's signature.
-     *
-     * @param nodeName - The name of the node to execute (must exist in TNodes)
-     * @param mapping - Typed function that takes the current state and returns the input for the node
-     * @param dynamicContext - Optional object to override the AI service or options for this specific step
-     * @returns New AxFlow instance with TState augmented with the node's result
-     *
-     * @example
-     * ```typescript
-     * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
-     * ```
-     */
+    private createExecuteStep;
     execute<TNodeName extends keyof TNodes & string, TAI extends Readonly<AxAIService>>(nodeName: TNodeName, mapping: (_state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext<TAI>): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    /**
-     * Apply optimized configuration to this flow and all node programs.
-     */
+    e<TNodeName extends keyof TNodes & string, TAI extends Readonly<AxAIService>>(nodeName: TNodeName, mapping: (_state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext<TAI>): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     applyOptimization(optimizedProgram: AxOptimizedProgram<any>): void;
     getOptimizableComponents(): readonly AxOptimizableComponent[];
     applyOptimizedComponents(updates: Readonly<Record<string, string>>): void;
-    /**
-     * Short alias for execute()
-     */
-    e<TNodeName extends keyof TNodes & string, TAI extends Readonly<AxAIService>>(nodeName: TNodeName, mapping: (_state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext<TAI>): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    /**
-     * Starts a conditional branch based on a predicate function.
-     *
-     * @param predicate - Function that takes state and returns a value to branch on
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.branch(state => state.qualityResult.needsMoreInfo)
-     *   .when(true)
-     *     .execute('queryGen', ...)
-     *   .when(false)
-     *     .execute('answer', ...)
-     *   .merge()
-     * ```
-     */
     branch(predicate: (_state: TState) => unknown): this;
-    /**
-     * Short alias for branch()
-     */
     b(predicate: (_state: TState) => unknown): this;
-    /**
-     * Defines a branch case for the current branch context.
-     *
-     * @param value - The value to match against the branch predicate result
-     * @returns this (for chaining)
-     */
     when(value: unknown): this;
-    /**
-     * Short alias for when()
-     */
     w(value: unknown): this;
-    /**
-     * 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
-     *
-     * 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
-     * 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>;
-    /**
-     * Short alias for merge()
-     */
     mg<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
-    /**
-     * 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
-     *
-     * @example
-     * ```typescript
-     * flow.parallel([
-     *   subFlow => subFlow.execute('retrieve1', state => ({ query: state.query1 })),
-     *   subFlow => subFlow.execute('retrieve2', state => ({ query: state.query2 })),
-     *   subFlow => subFlow.execute('retrieve3', state => ({ query: state.query3 }))
-     * ]).merge('documents', (docs1, docs2, docs3) => [...docs1, ...docs2, ...docs3])
-     * ```
-     */
-    parallel(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
+    parallel(branches: AxFlowTypedParallelBranch<TNodes, TState>[]): {
         merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (..._results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
             [K in TResultKey]: T;
         }>;
     };
-    /**
-     * Short alias for parallel()
-     */
-    p(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
+    p(branches: AxFlowTypedParallelBranch<TNodes, TState>[]): {
         merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (..._results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
             [K in TResultKey]: T;
         }>;
     };
-    /**
-     * Creates a feedback loop that jumps back to a labeled step if a condition is met.
-     *
-     * @param condition - Function that returns true to trigger the feedback loop
-     * @param targetLabel - The label to jump back to
-     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 10)
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.label('retry-point')
-     *   .execute('answer', ...)
-     *   .execute('qualityCheck', ...)
-     *   .feedback(state => state.qualityCheckResult.confidence < 0.7, 'retry-point')
-     * ```
-     */
     feedback(condition: (_state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
-    /**
-     * Short alias for feedback()
-     */
     fb(condition: (_state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
-    /**
-     * Marks the beginning of a loop block.
-     *
-     * @param condition - Function that takes the current state and returns a boolean
-     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 100)
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.while(state => state.iterations < 3, 10)
-     *   .map(state => ({ ...state, iterations: (state.iterations || 0) + 1 }))
-     *   .endWhile()
-     * ```
-     */
     while(condition: (state: TState) => boolean, maxIterations?: number): this;
-    /**
-     * Short alias for while()
-     */
     wh(condition: (_state: TState) => boolean, maxIterations?: number): this;
-    /**
-     * Marks the end of a loop block.
-     *
-     * @returns this (for chaining)
-     */
     endWhile(): this;
-    /**
-     * Short alias for endWhile()
-     */
     end(): this;
-    /**
-     * Derives a new field from an existing field by applying a transform function.
-     *
-     * If the input field contains an array, the transform function is applied to each
-     * array element in parallel with batch size control. If the input field contains
-     * a scalar value, the transform function is applied directly.
-     *
-     * @param outputFieldName - Name of the field to store the result
-     * @param inputFieldName - Name of the existing field to transform
-     * @param transformFn - Function to apply to each element (for arrays) or the value directly (for scalars)
-     * @param options - Options including batch size for parallel processing
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * // Parallel processing of array items
-     * flow.derive('processedItems', 'items', (item, index) => processItem(item), { batchSize: 5 })
-     *
-     * // Direct transformation of scalar value
-     * flow.derive('upperText', 'text', (text) => text.toUpperCase())
-     * ```
-     */
     derive<T>(outputFieldName: string, inputFieldName: string, transformFn: (value: any, index?: number, state?: TState) => T, options?: {
         batchSize?: number;
     }): this;
-    /**
-     * Gets execution plan information for debugging automatic parallelization
-     *
-     * @returns Object with execution plan details
-     */
     getExecutionPlan(): {
         totalSteps: number;
         parallelGroups: number;
         maxParallelism: number;
         autoParallelEnabled: boolean;
-        steps?: AxFlowExecutionStep[];
-        groups?: AxFlowParallelGroup[];
+        steps?: AxFlowExecutionPlanStep[];
+        groups?: AxFlowExecutionPlanGroup[];
     };
     getSignature(): AxSignature;
-    /**
-     * Creates a new AxFlow node from an existing signature by extending it with additional fields.
-     *
-     * @param name - The name of the new node
-     * @param baseSignature - The base signature to extend (string or AxSignature)
-     * @param extensions - Object defining how to extend the signature
-     * @returns New AxFlow instance with the extended node
-     *
-     * @example
-     * ```typescript
-     * // Create a chain-of-thought node
-     * flow.nodeExtended('reasoner', 'question:string -> answer:string', {
-     *   prependOutputs: [
-     *     { name: 'reasoning', type: f.string('Step-by-step reasoning').internal() }
-     *   ]
-     * })
-     *
-     * // Create a node with context and confidence
-     * flow.nodeExtended('analyzer', 'input:string -> output:string', {
-     *   appendInputs: [{ name: 'context', type: f.string('Context').optional() }],
-     *   appendOutputs: [{ name: 'confidence', type: f.number('Confidence score') }]
-     * })
-     * ```
-     */
     nodeExtended<TName extends string>(name: TName, baseSignature: string | AxSignature, extensions: {
         prependInputs?: Array<{
             name: string;
@@ -12068,9 +10164,6 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     }): AxFlow<IN, OUT, TNodes & {
         [K in TName]: AxGen<AxGenIn, AxGenOut>;
     }, TState>;
-    /**
-     * Short alias for nodeExtended() - creates nodes with extended signatures
-     */
     nx<TName extends string>(name: TName, baseSignature: string | AxSignature, extensions: {
         prependInputs?: Array<{
             name: string;
@@ -12091,108 +10184,8 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     }): AxFlow<IN, OUT, TNodes & {
         [K in TName]: AxGen<AxGenIn, AxGenOut>;
     }, TState>;
-    /**
-     * Applies a final transformation to the state object that updates both state and output type.
-     * This is specifically designed for terminal transformations that shape the final output.
-     *
-     * @param transform - Function that takes the current state and returns the final output
-     * @returns New AxFlow instance with updated OUT and TState types
-     *
-     * @example
-     * ```
-     * const result = await flow
-     *   .node('analyzer', 'userQuestion:string -> analysisResult:string')
-     *   .execute('analyzer', state => ({ userQuestion: state.userQuestion }))
-     *   .mapOutput(state => ({
-     *     // Note: Node results are typed as AxFieldValue, so you may need to cast
-     *     finalAnswer: state.analyzerResult.analysisResult as string
-     *   }))
-     *   .forward(ai, { userQuestion: 'test' });
-     *
-     * // result is typed as { finalAnswer: string }
-     * ```
-     */
-    mapOutput<TOutput>(transform: (_state: TState) => TOutput): AxFlow<IN, TOutput, TNodes, TOutput & TState>;
-    /**
-     * Short alias for mapOutput()
-     */
-    mo<TOutput>(transform: (_state: TState) => TOutput): AxFlow<IN, TOutput, TNodes, TOutput & TState>;
-}
-/**
- * Factory function to create a new AxFlow instance
- * Similar to ai() for AI services, this creates a fluent flow
- *
- * @param options - Optional configuration for the flow
- * @returns New AxFlow instance
- *
- * @example
- * ```typescript
- * // Input type is required - provides type safety throughout the flow
- * const workflow = flow<{ userInput: string }>()
- *   .node('summarizer', 'documentText:string -> summaryText:string')
- *   .execute('summarizer', state => ({ documentText: state.userInput }));
- *
- * // Complex input types work great for multi-field workflows
- * const complexFlow = flow<{ userQuestion: string; context: string }>()
- *   .map(state => ({
- *     ...state,
- *     processedQuestion: state.userQuestion.toUpperCase() // TypeScript knows this exists!
- *   }));
- * ```
- */
-/**
- * Creates a new AxFlow instance with required input type specification.
- *
- * The input type must be specified upfront to enable proper type inference
- * throughout the flow construction and execution.
- *
- * @example
- * ```typescript
- * // ✅ Define input type upfront for better type safety
- * const workflow = flow<{ userInput: string, options?: any }>()
- *   .map(state => ({ ...state, processedInput: state.userInput.toUpperCase() }))
- *   .node('analyzer', 'processedInput:string -> result:string')
- *
- * // ✅ Simple input types work too
- * const simpleFlow = flow<{ documentText: string }>()
- *   .node('summarizer', 'documentText:string -> summary:string')
- * ```
- */
-declare function flow<TInput extends Record<string, any>, TOutput = {}>(options?: {
-    autoParallel?: boolean;
-    batchSize?: number;
-    logger?: AxFlowLoggerFunction;
-    debug?: boolean;
-}): AxFlow<TInput, TOutput, {}, TInput>;
-
-/**
- * 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, string> & AxTunable<AxGenIn, AxGenOut> & AxUsable>);
-    execute<TAI extends Readonly<AxAIService>>(nodeName: string, mapping: (state: AxFlowState) => Record<string, AxFieldValue>, dynamicContext?: AxFlowDynamicContext<TAI>): this;
-    map(transform: (state: AxFlowState) => AxFlowState): this;
-    executeSteps(initialState: AxFlowState, context: Readonly<{
-        mainAi: AxAIService;
-        mainOptions?: AxProgramForwardOptions<string>;
-    }>): Promise<AxFlowState>;
-}
-/**
- * Typed implementation of the sub-context for parallel execution with full type safety
- */
-declare class AxFlowTypedSubContextImpl<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> implements AxFlowTypedSubContext<TNodes, TState> {
-    private readonly nodeGenerators;
-    private readonly steps;
-    constructor(nodeGenerators: Map<string, AxGen<AxGenIn, AxGenOut> | AxProgram<AxGenIn, AxGenOut>>);
-    execute<TNodeName extends keyof TNodes & string, TAI extends Readonly<AxAIService>>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext<TAI>): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
-    executeSteps(initialState: TState, context: Readonly<{
-        mainAi: AxAIService;
-        mainOptions?: AxProgramForwardOptions<string>;
-    }>): Promise<AxFlowState>;
 }
+declare function flow<TInput extends Record<string, any> = Record<string, unknown>, TOutput = {}>(options?: AxFlowOptions): AxFlow<TInput, TOutput, {}, TInput>;
 
 interface AxDockerContainer {
     Id: string;
@@ -12313,26 +10306,12 @@ declare class AxEmbeddingAdapter {
 }
 
 /**
- * Fine-grained Node Permission Model allowlist. Scopes `--allow-fs-*` and
- * gates additional `--allow-*` flags that aren't covered by the high-level
- * permission enum.
- */
-type AxJSRuntimeNodePermissionAllowlist = Readonly<{
-    fsRead?: readonly string[];
-    fsWrite?: readonly string[];
-    childProcess?: boolean;
-    addons?: boolean;
-    wasi?: boolean;
-}>;
-/**
- * Node worker_threads resource limits passthrough.
+ * Host-side security configuration helpers for AxJSRuntime.
+ *
+ * This module intentionally contains no worker-session state. It normalizes the
+ * public security options into runtime/worker flags used by jsRuntime.ts and
+ * jsRuntimeWorkers.ts.
  */
-type AxJSRuntimeResourceLimits = Readonly<{
-    maxOldGenerationSizeMb?: number;
-    maxYoungGenerationSizeMb?: number;
-    codeRangeSizeMb?: number;
-    stackSizeMb?: number;
-}>;
 /**
  * Permissions that can be granted to the RLM JS interpreter sandbox.
  * By default all dangerous globals are blocked; users opt in via this enum.
@@ -12360,6 +10339,28 @@ declare enum AxJSRuntimePermission {
     /** node:child_process — gates --allow-child-process and Deno run */
     CHILD_PROCESS = "child-process"
 }
+/**
+ * Fine-grained Node Permission Model allowlist. Scopes `--allow-fs-*` and
+ * gates additional `--allow-*` flags that aren't covered by the high-level
+ * permission enum.
+ */
+type AxJSRuntimeNodePermissionAllowlist = Readonly<{
+    fsRead?: readonly string[];
+    fsWrite?: readonly string[];
+    childProcess?: boolean;
+    addons?: boolean;
+    wasi?: boolean;
+}>;
+/**
+ * Node worker_threads resource limits passthrough.
+ */
+type AxJSRuntimeResourceLimits = Readonly<{
+    maxOldGenerationSizeMb?: number;
+    maxYoungGenerationSizeMb?: number;
+    codeRangeSizeMb?: number;
+    stackSizeMb?: number;
+}>;
+
 type AxJSRuntimeOutputMode = 'return' | 'stdout';
 /**
  * Browser-compatible JavaScript interpreter for RLM using Web Workers.
@@ -12414,7 +10415,9 @@ declare class AxJSRuntime implements AxCodeRuntime {
          */
         blockDynamicImport?: boolean;
         /**
-         * Module specifier allowlist when `blockDynamicImport` is true.
+         * Module specifier allowlist when `blockDynamicImport` is true. This is
+         * a narrow dynamic-import gate: allowlisted specifiers are attempted, but
+         * full Node module namespace passthrough depends on Node vm semantics.
          * Default: [].
          */
         allowedModules?: readonly string[];
@@ -12475,9 +10478,9 @@ declare class AxJSRuntime implements AxCodeRuntime {
      * Computes Node execArgv for the Permission Model when it should engage,
      * otherwise returns undefined.
      *
-     * - 'auto': engages on Node 23.5+ when FILESYSTEM or CHILD_PROCESS is in
-     *   permissions; skips silently otherwise.
-     * - true: engages unconditionally; hard-fails on Node < 23.5.
+     * - 'auto': engages unconditionally on supported Node versions; skips
+     *   silently where the Node Permission Model is unavailable.
+     * - true: engages unconditionally; hard-fails on Node < 20.
      * - false: never engages.
      */
     private computeNodeExecArgv;
@@ -12841,342 +10844,37 @@ declare class AxMCPHTTPSSETransport implements AxMCPTransport {
     close(): void;
 }
 
-/**
- * Advanced Multi-hop RAG with iterative query refinement, context accumulation,
- * parallel sub-queries, and self-healing quality feedback loops
- *
- * @param queryFn - Function to execute search queries and return results
- * @param options - Configuration options
- * @returns AxFlow instance with advanced RAG capability
- */
-declare const axRAG: (queryFn: (query: string) => Promise<string>, options?: {
-    maxHops?: number;
-    qualityThreshold?: number;
-    maxIterations?: number;
-    qualityTarget?: number;
-    disableQualityHealing?: boolean;
-    logger?: AxFlowLoggerFunction;
-    debug?: boolean;
-}) => AxFlow<{
-    originalQuestion: string;
-}, {
-    finalAnswer: string;
-    totalHops: number;
-    retrievedContexts: string[];
-    iterationCount: number;
-    healingAttempts: number;
-    qualityAchieved: number;
-}, {
-    queryGenerator: InferAxGen<"originalQuestion:string, previousContext?:string -> searchQuery:string, queryReasoning:string">;
-} & {
-    contextualizer: InferAxGen<"retrievedDocument:string, accumulatedContext?:string -> enhancedContext:string">;
-} & {
-    qualityAssessor: InferAxGen<"currentContext:string, originalQuestion:string -> completenessScore:number, missingAspects:string[]">;
-} & {
-    questionDecomposer: InferAxGen<"complexQuestion:string -> subQuestions:string[], decompositionReason:string">;
-} & {
-    evidenceSynthesizer: InferAxGen<"collectedEvidence:string[], originalQuestion:string -> synthesizedEvidence:string, evidenceGaps:string[]">;
-} & {
-    gapAnalyzer: InferAxGen<"synthesizedEvidence:string, evidenceGaps:string[], originalQuestion:string -> needsMoreInfo:boolean, focusedQueries:string[]">;
-} & {
-    answerGenerator: InferAxGen<"finalContext:string, originalQuestion:string -> comprehensiveAnswer:string, confidenceLevel:number">;
-} & {
-    queryRefiner: InferAxGen<"originalQuestion:string, currentContext:string, missingAspects:string[] -> refinedQuery:string">;
-} & {
-    qualityValidator: InferAxGen<"generatedAnswer:string, userQuery:string -> qualityScore:number, issues:string[]">;
-} & {
-    answerHealer: InferAxGen<"originalAnswer:string, healingDocument:string, issues?:string[] -> healedAnswer:string">;
-}, {
-    currentAnswer: string;
-    currentQuality: number;
-    currentIssues: string[];
-    shouldContinueHealing: boolean;
-    healingResult: {
-        healingDocument: string;
-    };
-    healingAttempts: number;
-    allEvidence: string[];
-    evidenceSources: string[];
-    needsMoreInfo: boolean;
-    synthesizedEvidence: string;
-    retrievalResults: string[];
-    currentQueries: string[];
-    iteration: number;
-    searchQuery: string;
-    accumulatedContext: string;
-    retrievedContexts: string[];
-    completenessScore: number;
-    shouldContinue: boolean;
-    retrievalResult: {
-        retrievedDocument: string;
-        retrievalConfidence: number;
-    };
-    currentHop: number;
-    maxHops: number;
-    qualityThreshold: number;
-    maxIterations: number;
-    qualityTarget: number;
-    disableQualityHealing: boolean;
-    originalQuestion: string;
-    queryGeneratorResult: BuildObject<[{
-        name: "searchQuery";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }, {
-        name: "queryReasoning";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }], "output">;
-    contextualizerResult: BuildObject<[{
-        name: "enhancedContext";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }], "output">;
-    qualityAssessorResult: BuildObject<[{
-        name: "completenessScore";
-        optional: false;
-        internal: false;
-    } & {
-        type: "number";
-    }, {
-        name: "missingAspects";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string[]";
-    }], "output">;
-    queryRefinerResult: BuildObject<[{
-        name: "refinedQuery";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }], "output">;
-    questionDecomposerResult: BuildObject<[{
-        name: "subQuestions";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string[]";
-    }, {
-        name: "decompositionReason";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }], "output">;
-    evidenceSynthesizerResult: BuildObject<[{
-        name: "synthesizedEvidence";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }, {
-        name: "evidenceGaps";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string[]";
-    }], "output">;
-    gapAnalyzerResult: BuildObject<[{
-        name: "needsMoreInfo";
-        optional: false;
-        internal: false;
-    } & {
-        type: "boolean";
-    }, {
-        name: "focusedQueries";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string[]";
-    }], "output">;
-    answerGeneratorResult: BuildObject<[{
-        name: "comprehensiveAnswer";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }, {
-        name: "confidenceLevel";
-        optional: false;
-        internal: false;
-    } & {
-        type: "number";
-    }], "output">;
-    qualityValidatorResult: BuildObject<[{
-        name: "qualityScore";
-        optional: false;
-        internal: false;
-    } & {
-        type: "number";
-    }, {
-        name: "issues";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string[]";
-    }], "output">;
-    answerHealerResult: BuildObject<[{
-        name: "healedAnswer";
-        optional: false;
-        internal: false;
-    } & {
-        type: "string";
-    }], "output">;
-}>;
-
-/**
- * AxTraceLogger - Decorator that intercepts AxGen.forward() calls and logs traces.
- *
- * This provides a non-intrusive way to add logging to any AxGen instance
- * without modifying the original class.
- */
-
-/**
- * Configuration options for AxTraceLogger
- */
-interface AxTraceLoggerOptions {
-    /** Unique identifier for this agent/generator */
-    name: string;
-    /** Storage backend for persisting traces */
-    storage: AxStorage;
-    /** Whether to include input values in traces (default: true) */
-    logInputs?: boolean;
-    /** Whether to include output values in traces (default: true) */
-    logOutputs?: boolean;
-    /** Custom metadata to include in all traces */
-    metadata?: Record<string, unknown>;
-    /** Callback when a trace is logged */
-    onTrace?: (trace: AxTrace) => void;
-    /** Whether logging errors should throw (default: false - errors are silently caught) */
-    throwOnError?: boolean;
-}
-/**
- * AxTraceLogger wraps an AxGen instance to automatically log all forward() calls.
- *
- * @example
- * ```typescript
- * const gen = ax(`query -> response`);
- * const storage = new AxMemoryStorage();
- *
- * const tracedGen = new AxTraceLogger(gen, {
- *   agentId: 'my-agent',
- *   storage,
- * });
- *
- * // Use exactly like AxGen
- * const result = await tracedGen.forward(ai, { query: 'Hello' });
- *
- * // Traces are automatically saved to storage
- * const traces = await storage.getTraces('my-agent');
- * ```
- */
-declare class AxTraceLogger<IN extends AxGenIn, OUT extends AxGenOut> {
-    private gen;
-    private options;
-    constructor(gen: AxGen<IN, OUT>, options: AxTraceLoggerOptions);
-    /**
-     * Streaming forward call to the underlying AxGen with trace logging.
-     */
-    streamingForward(ai: AxAIService, values: IN, options?: Readonly<AxProgramForwardOptions<string>>): AxGenStreamingOut<OUT>;
-    /**
-     * Forward call to the underlying AxGen with trace logging.
-     */
-    forward(ai: AxAIService, values: IN, options?: Readonly<AxProgramForwardOptions<string>>): Promise<OUT>;
-    /**
-     * Save trace to storage with error handling.
-     */
-    private saveTrace;
-    /**
-     * Get the underlying AxGen instance.
-     */
-    getGen(): AxGen<IN, OUT>;
-    /**
-     * Get the agent ID.
-     */
-    getName(): string;
-    /**
-     * Get the storage backend.
-     */
-    getStorage(): AxStorage;
-    /**
-     * Update the metadata for future traces.
-     */
-    setMetadata(metadata: Record<string, unknown>): void;
-    /**
-     * Clone the logger with a new underlying AxGen.
-     */
-    clone(newGen?: AxGen<IN, OUT>): AxTraceLogger<IN, OUT>;
-}
-
 declare const axSpanAttributes: {
-    LLM_SYSTEM: string;
-    LLM_OPERATION_NAME: string;
-    LLM_REQUEST_MODEL: string;
-    LLM_REQUEST_MAX_TOKENS: string;
-    LLM_REQUEST_TEMPERATURE: string;
-    LLM_REQUEST_TOP_K: string;
-    LLM_REQUEST_FREQUENCY_PENALTY: string;
-    LLM_REQUEST_PRESENCE_PENALTY: string;
-    LLM_REQUEST_STOP_SEQUENCES: string;
-    LLM_REQUEST_LLM_IS_STREAMING: string;
-    LLM_REQUEST_TOP_P: string;
-    LLM_RESPONSE_ID: string;
-    LLM_RESPONSE_MODEL: string;
-    LLM_CONVERSATION_ID: string;
-    LLM_USAGE_INPUT_TOKENS: string;
-    LLM_USAGE_OUTPUT_TOKENS: string;
-    LLM_USAGE_TOTAL_TOKENS: string;
-    LLM_USAGE_THOUGHTS_TOKENS: string;
-    AX_SESSION_ID: string;
-    AX_PROVIDER_REQUEST_ID: string;
-    AX_PROVIDER_SESSION_ID: string;
-    DB_SYSTEM: string;
-    DB_TABLE: string;
-    DB_NAMESPACE: string;
-    DB_ID: string;
-    DB_QUERY_TEXT: string;
-    DB_VECTOR: string;
-    DB_OPERATION_NAME: string;
-    DB_VECTOR_QUERY_TOP_K: string;
-    DB_QUERY_EMBEDDINGS: string;
-    DB_QUERY_RESULT: string;
-    DB_QUERY_EMBEDDINGS_VECTOR: string;
-    DB_QUERY_RESULT_ID: string;
-    DB_QUERY_RESULT_SCORE: string;
-    DB_QUERY_RESULT_DISTANCE: string;
-    DB_QUERY_RESULT_METADATA: string;
-    DB_QUERY_RESULT_VECTOR: string;
-    DB_QUERY_RESULT_DOCUMENT: string;
+    readonly LLM_SYSTEM: "gen_ai.system";
+    readonly LLM_OPERATION_NAME: "gen_ai.operation.name";
+    readonly LLM_REQUEST_MODEL: "gen_ai.request.model";
+    readonly LLM_REQUEST_MAX_TOKENS: "gen_ai.request.max_tokens";
+    readonly LLM_REQUEST_TEMPERATURE: "gen_ai.request.temperature";
+    readonly LLM_REQUEST_TOP_K: "gen_ai.request.top_k";
+    readonly LLM_REQUEST_FREQUENCY_PENALTY: "gen_ai.request.frequency_penalty";
+    readonly LLM_REQUEST_PRESENCE_PENALTY: "gen_ai.request.presence_penalty";
+    readonly LLM_REQUEST_STOP_SEQUENCES: "gen_ai.request.stop_sequences";
+    readonly LLM_REQUEST_LLM_IS_STREAMING: "gen_ai.request.llm_is_streaming";
+    readonly LLM_REQUEST_TOP_P: "gen_ai.request.top_p";
+    readonly LLM_RESPONSE_ID: "gen_ai.response.id";
+    readonly LLM_RESPONSE_MODEL: "gen_ai.response.model";
+    readonly LLM_CONVERSATION_ID: "gen_ai.conversation.id";
+    readonly LLM_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens";
+    readonly LLM_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens";
+    readonly LLM_USAGE_TOTAL_TOKENS: "gen_ai.usage.total_tokens";
+    readonly LLM_USAGE_THOUGHTS_TOKENS: "gen_ai.usage.thoughts_tokens";
+    readonly AX_SESSION_ID: "ax.session.id";
+    readonly AX_PROVIDER_REQUEST_ID: "ax.provider.request_id";
+    readonly AX_PROVIDER_SESSION_ID: "ax.provider.session_id";
 };
 declare const axSpanEvents: {
-    GEN_AI_USER_MESSAGE: string;
-    GEN_AI_SYSTEM_MESSAGE: string;
-    GEN_AI_ASSISTANT_MESSAGE: string;
-    GEN_AI_TOOL_MESSAGE: string;
-    GEN_AI_CHOICE: string;
-    GEN_AI_USAGE: string;
-};
-declare enum AxLLMRequestTypeValues {
-    COMPLETION = "completion",
-    CHAT = "chat",
-    RERANK = "rerank",
-    UNKNOWN = "unknown"
-}
-declare enum AxSpanKindValues {
-    WORKFLOW = "workflow",
-    TASK = "task",
-    AGENT = "agent",
-    TOOL = "tool",
-    UNKNOWN = "unknown"
-}
+    readonly GEN_AI_USER_MESSAGE: "gen_ai.user.message";
+    readonly GEN_AI_SYSTEM_MESSAGE: "gen_ai.system.message";
+    readonly GEN_AI_ASSISTANT_MESSAGE: "gen_ai.assistant.message";
+    readonly GEN_AI_TOOL_MESSAGE: "gen_ai.tool.message";
+    readonly GEN_AI_CHOICE: "gen_ai.choice";
+    readonly GEN_AI_USAGE: "gen_ai.usage";
+};
 
 interface AxRateLimiterTokenUsageOptions {
     debug?: boolean;
@@ -13193,4 +10891,4 @@ declare class AxRateLimiterTokenUsage {
     acquire(tokens: number): Promise<void>;
 }
 
-export { AxACE, type AxACEBullet, type AxACECuratorOperation, type AxACECuratorOperationType, type AxACECuratorOutput, type AxACEFeedbackEvent, type AxACEGeneratorOutput, type AxACEOptimizationArtifact, AxACEOptimizedProgram, type AxACEOptions, type AxACEPlaybook, type AxACEReflectionOutput, type AxACEResult, AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicEffortLevel, type AxAIAnthropicEffortLevelMapping, type AxAIAnthropicErrorEvent, type AxAIAnthropicFunctionTool, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicOutputConfig, type AxAIAnthropicPingEvent, type AxAIAnthropicRequestTool, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, type AxAIAnthropicThinkingWire, AxAIAnthropicVertexModel, type AxAIAnthropicWebSearchTool, 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 AxAIGoogleGeminiCacheCreateRequest, type AxAIGoogleGeminiCacheResponse, type AxAIGoogleGeminiCacheUpdateRequest, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, type AxAIGoogleGeminiRetrievalConfig, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingLevel, type AxAIGoogleGeminiThinkingLevelMapping, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleMaps, 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 AxAIModelCatalogAudioSupport, type AxAIModelCatalogFilter, type AxAIModelCatalogModel, type AxAIModelCatalogModelCapabilities, type AxAIModelCatalogModelType, type AxAIModelCatalogOptions, type AxAIModelCatalogProvider, type AxAIModelCatalogProviderName, 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, AxAIOpenRouter, type AxAIOpenRouterArgs, 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, type AxAIServiceModelType, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, AxAITogether, type AxAITogetherArgs, type AxAITogetherChatModel, AxAITogetherModel, AxAIWebLLM, type AxAIWebLLMArgs, type AxAIWebLLMChatRequest, type AxAIWebLLMChatResponse, type AxAIWebLLMChatResponseDelta, type AxAIWebLLMConfig, type AxAIWebLLMEmbedModel, type AxAIWebLLMEmbedRequest, type AxAIWebLLMEmbedResponse, AxAIWebLLMModel, type AxAPI, type AxAPIConfig, type AxAPIResponseMetadata, AxAgent, type AxAgentActorTurnCallback, type AxAgentActorTurnCallbackArgs, type AxAgentClarification, type AxAgentClarificationChoice, AxAgentClarificationError, type AxAgentClarificationKind, type AxAgentCompletionProtocol, type AxAgentConfig, type AxAgentContextEvent, AxAgentContextMap, type AxAgentContextMapConfig, type AxAgentContextMapOperation, type AxAgentContextMapOptions, type AxAgentContextMapSnapshot, type AxAgentContextMapUpdateResult, type AxAgentContextPressure, type AxAgentContextStage, type AxAgentDemos, type AxAgentDiscoveryPromptState, type AxAgentEvalDataset, type AxAgentEvalFunctionCall, type AxAgentEvalPrediction, type AxAgentEvalTask, type AxAgentExecutorResultPayload, type AxAgentExecutorTurnCallback, type AxAgentExecutorTurnCallbackArgs, type AxAgentForwardOptions, type AxAgentFunction, type AxAgentFunctionCall, type AxAgentFunctionCallRecorder, type AxAgentFunctionCollection, type AxAgentFunctionExample, type AxAgentFunctionGroup, type AxAgentFunctionModuleMeta, type AxAgentGuidanceLogEntry, type AxAgentGuidancePayload, type AxAgentGuidanceState, type AxAgentIdentity, type AxAgentInputUpdateCallback, type AxAgentInternalCompletionPayload, type AxAgentJudgeEvalInput, type AxAgentJudgeEvalOutput, type AxAgentJudgeInput, type AxAgentJudgeOptions, type AxAgentJudgeOutput, type AxAgentMemoriesSearchFn, type AxAgentMemoryEntry, type AxAgentMemoryResult, type AxAgentOnContextEvent, type AxAgentOnFunctionCall, type AxAgentOptimizationTargetDescriptor, type AxAgentOptimizeOptions, type AxAgentOptimizeResult, type AxAgentOptimizeTarget, type AxAgentOptions, AxAgentProtocolCompletionSignal, type AxAgentRecursionOptions, type AxAgentRecursiveExpensiveNode, type AxAgentRecursiveFunctionCall, type AxAgentRecursiveNodeRole, type AxAgentRecursiveStats, type AxAgentRecursiveTargetId, type AxAgentRecursiveTraceNode, type AxAgentRecursiveTurn, type AxAgentRecursiveUsage, type AxAgentRuntimeCompletionState, type AxAgentRuntimeExecutionContext, type AxAgentRuntimeInputState, type AxAgentSkillResult, type AxAgentSkillsPromptState, type AxAgentSkillsSearchFn, type AxAgentState, type AxAgentStateActionLogEntry, type AxAgentStateCheckpointState, type AxAgentStateExecutorModelState, type AxAgentStateRuntimeEntry, type AxAgentStreamingForwardOptions, type AxAgentStructuredClarification, type AxAgentTestCompletionPayload, type AxAgentTestResult, type AxAgentUsage, type AxAgentUsedMemoriesCallback, type AxAgentUsedMemory, type AxAgentUsedSkill, type AxAgentUsedSkillsCallback, type AxAgentic, type AxAnyAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, type AxAudioFormat, type AxAudioInput, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, type AxChatAudioConfig, type AxChatAudioOutput, type AxChatLogEntry, type AxChatLogMessage, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpoint, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCitation, type AxCodeInterpreter, type AxCodeRuntime, type AxCodeSession, type AxCodeSessionSnapshot, type AxCodeSessionSnapshotEntry, type AxCompileOptions, AxContentProcessingError, type AxContentProcessingServices, type AxContextCacheInfo, type AxContextCacheOperation, type AxContextCacheOptions, type AxContextCacheRegistry, type AxContextCacheRegistryEntry, type AxContextFieldInput, type AxContextFieldPromptConfig, type AxContextPolicyBudget, type AxContextPolicyConfig, type AxContextPolicyPreset, 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, type AxDateRange, type AxDateRangeValue, type AxDebugChatResponseUsage, AxDefaultCostTracker, AxDefaultResultReranker, type AxDiscoveryTurnSummary, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxExamples, type AxExecutorModelPolicy, type AxExecutorModelPolicyEntry, type AxField, type AxFieldOptions, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, type AxFlowAutoParallelConfig, type AxFlowBranchContext, type AxFlowBranchEvaluationData, type AxFlowCompleteData, AxFlowDependencyAnalyzer, type AxFlowDynamicContext, type AxFlowErrorData, AxFlowExecutionPlanner, type AxFlowExecutionStep, type AxFlowLogData, type AxFlowLoggerData, type AxFlowLoggerFunction, type AxFlowNodeDefinition, type AxFlowParallelBranch, type AxFlowParallelGroup, type AxFlowParallelGroupCompleteData, type AxFlowParallelGroupStartData, type AxFlowStartData, type AxFlowState, type AxFlowStepCompleteData, type AxFlowStepFunction, type AxFlowStepStartData, type AxFlowSubContext, AxFlowSubContextImpl, type AxFlowTypedParallelBranch, type AxFlowTypedSubContext, AxFlowTypedSubContextImpl, type AxFlowable, type AxFluentFieldInfo, AxFluentFieldType, type AxForwardable, type AxFunction, type AxFunctionCallRecord, type AxFunctionCallTrace, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, type AxFunctionResultFormatter, AxGEPA, type AxGEPAAdapter, type AxGEPABatchEvaluation, type AxGEPABatchRow, type AxGEPABootstrapOptions, type AxGEPAComponentBanditState, AxGEPAComponentSelector, type AxGEPAComponentTarget, type AxGEPAEvaluationBatch, type AxGEPAEvaluationState, type AxGEPAOptimizationReport, type AxGEPAReflectiveTuple, type AxGEPATraceSummary, type AxGEPATraceSummaryCall, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenInput, type AxGenMetricsInstruments, type AxGenOut, type AxGenOutput, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, type AxInternalSpeechRequest, type AxInternalTranscriptionRequest, AxJSRuntime, type AxJSRuntimeNodePermissionAllowlist, type AxJSRuntimeOutputMode, AxJSRuntimePermission, type AxJSRuntimeResourceLimits, type AxJudgeForwardOptions, type AxJudgeOptions, AxLLMRequestTypeValues, AxLearn, type AxLearnArtifact, type AxLearnCheckpointMode, type AxLearnCheckpointState, type AxLearnContinuousOptions, type AxLearnMode, type AxLearnOptimizeOptions, type AxLearnOptions, type AxLearnPlaybook, type AxLearnPlaybookOptions, type AxLearnPlaybookSummary, type AxLearnProgress, type AxLearnResult, type AxLearnUpdateFeedback, type AxLearnUpdateInput, type AxLearnUpdateOptions, type AxLlmQueryBudgetState, type AxLlmQueryPromptMode, type AxLoggerData, type AxLoggerFunction, type AxMCPBlobResourceContents, AxMCPClient, type AxMCPEmbeddedResource, type AxMCPFunctionDescription, AxMCPHTTPSSETransport, type AxMCPImageContent, type AxMCPInitializeParams, type AxMCPInitializeResult, type AxMCPJSONRPCErrorResponse, type AxMCPJSONRPCNotification, type AxMCPJSONRPCRequest, type AxMCPJSONRPCResponse, type AxMCPJSONRPCSuccessResponse, type AxMCPOAuthOptions, type AxMCPPrompt, type AxMCPPromptArgument, type AxMCPPromptGetResult, type AxMCPPromptMessage, type AxMCPPromptsListResult, type AxMCPResource, type AxMCPResourceReadResult, type AxMCPResourceTemplate, type AxMCPResourceTemplatesListResult, type AxMCPResourcesListResult, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPTextContent, type AxMCPTextResourceContents, type AxMCPToolsListResult, type AxMCPTransport, AxMediaNotSupportedError, AxMemory, type AxMemoryData, type AxMemoryMessageValue, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, type AxMultiProviderConfig, AxMultiServiceRouter, type AxMutableDiscoveryPromptState, type AxMutableSkillsPromptState, type AxNamedProgramInstance, type AxNormalizedAgentEvalDataset, type AxOptimizableComponent, type AxOptimizableValidator, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizedProgram, AxOptimizedProgramImpl, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerLoggerData, type AxOptimizerLoggerFunction, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, type AxPreparedChatRequest, type AxPreparedRestoredState, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramForwardOptionsWithModels, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramStreamingForwardOptionsWithModels, type AxProgramTrace, type AxProgramUsage, type AxProgrammable, type AxPromptMetrics, AxPromptTemplate, type AxPromptTemplateOptions, type AxProviderMetadata, AxProviderRouter, type AxRLMConfig, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRenderedPrompt, type AxRerankerIn, type AxRerankerOut, type AxResolvedContextPolicy, type AxResolvedExecutorModelPolicy, type AxResolvedExecutorModelPolicyEntry, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxRolloutTrace, type AxRoutingResult, type AxRuntimePrimitive, type AxRuntimePrimitiveExample, type AxRuntimePrimitiveSignature, type AxRuntimePrimitiveStage, type AxSamplePickerOptions, type AxSelfTuningConfig, type AxSerializedOptimizedProgram, type AxSetExamplesOptions, AxSignature, AxSignatureBuilder, type AxSignatureConfig, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxSpeechConfig, type AxSpeechRequest, type AxSpeechResponse, type AxStageDefinitionBuildOptions, type AxStageOptions, type AxStepContext, AxStepContextImpl, type AxStepHooks, type AxStepUsage, AxStopFunctionCallException, type AxStorage, type AxStorageQuery, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxSynth, type AxSynthExample, type AxSynthOptions, type AxSynthResult, type AxSynthesizerInit, type AxSynthesizerOptions, type AxSynthesizerRole, AxTestPrompt, type AxThoughtBlockItem, AxTokenLimitError, type AxTokenUsage, type AxTrace, AxTraceLogger, type AxTraceLoggerOptions, type AxTranscriptionRequest, type AxTranscriptionResponse, type AxTranscriptionSegment, type AxTunable, type AxTypedExample, type AxUsable, type AxWorkerRuntimeConfig, agent, ai, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGoogleGeminiLiveAudioDefaultConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIGrokVoiceDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIAudioDefaultConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIRealtimeDefaultConfig, axAIOpenAIRealtimeTranscriptionDefaultConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIOpenRouterDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axAIWebLLMCreativeConfig, axAIWebLLMDefaultConfig, axAnalyzeChatPromptRequirements, axAnalyzeRequestRequirements, axApplyOpenAIChatAudioRequest, axAudioFormatFromMimeType, axAudioInputFilename, axAudioInputToBlob, axAudioMimeType, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axBuildDistillerDefinition, axBuildExecutorDefinition, axBuildResponderDefinition, axCheckMetricsHealth, axConcatBase64, axCreateDefaultColorLogger, axCreateDefaultOptimizerColorLogger, axCreateDefaultOptimizerTextLogger, axCreateDefaultTextLogger, axCreateFlowColorLogger, axCreateFlowTextLogger, axCreateGeminiLiveAudioApi, axCreateGrokRealtimeApi, axCreateJSRuntime, axCreateOpenAIRealtimeApi, axDefaultFlowLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axDeserializeOptimizedProgram, axFetchJsonSpeech, axFetchMultipartTranscription, axGetCompatibilityReport, axGetFormatCompatibility, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGetProvidersWithMediaSupport, axGetSupportedAIModels, axGlobals, axGoogleGeminiLiveAudioDefaults, axIsAudioOutputEnabled, axIsGeminiLiveAudioModel, axIsGrokVoiceModel, axIsOpenAIChatAudioModel, axIsOpenAIRealtimeModel, axIsOpenAIRealtimeTranscriptionModel, axMapGeminiLiveAudioPart, axMapOpenAIChatAudioDelta, axMapOpenAIChatAudioResponse, axMapOpenAIInputAudioPart, axMergeChatAudioConfig, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axModelInfoWebLLM, axNormalizeOpenAIUsage, axNormalizeTranscriptionResponse, axOpenAIChatAudioDefaults, axOptimizableValidators, axProcessContentForProvider, axRAG, axResolveGeminiLiveAudioConfig, axResolveGrokRealtimeAudioConfig, axResolveOpenAIChatAudioConfig, axResolveOpenAIRealtimeAudioConfig, axRuntimePrimitives, axScoreProvidersForRequest, axSelectOptimalProvider, axSerializeOptimizedProgram, axShouldUseGeminiLiveAudio, axShouldUseGrokRealtime, axShouldUseOpenAIRealtime, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, axValidateGeminiLiveAudioInput, axValidateProviderCapabilities, axWorkerRuntime, f, flow, fn, 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 AxAIAnthropicEffortLevel, type AxAIAnthropicEffortLevelMapping, type AxAIAnthropicErrorEvent, type AxAIAnthropicFunctionTool, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicOutputConfig, type AxAIAnthropicPingEvent, type AxAIAnthropicRequestTool, type AxAIAnthropicStopDetails, type AxAIAnthropicTaskBudget, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, type AxAIAnthropicThinkingWire, AxAIAnthropicVertexModel, type AxAIAnthropicWebSearchTool, 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 AxAIGoogleGeminiCacheCreateRequest, type AxAIGoogleGeminiCacheResponse, type AxAIGoogleGeminiCacheUpdateRequest, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, type AxAIGoogleGeminiRetrievalConfig, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingLevel, type AxAIGoogleGeminiThinkingLevelMapping, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleMaps, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelCatalogAudioSupport, type AxAIModelCatalogFilter, type AxAIModelCatalogModel, type AxAIModelCatalogModelCapabilities, type AxAIModelCatalogModelType, type AxAIModelCatalogOptions, type AxAIModelCatalogProvider, type AxAIModelCatalogProviderName, type AxAIModelList, type AxAIModelListBase, type AxAIModels, 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, 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 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, 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, type AxAIServiceModelType, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, type AxAPI, type AxAPIConfig, type AxAPIResponseMetadata, AxAgent, type AxAgentActorTurnCallback, type AxAgentActorTurnCallbackArgs, type AxAgentClarification, type AxAgentClarificationChoice, AxAgentClarificationError, type AxAgentClarificationKind, type AxAgentCompletionProtocol, type AxAgentConfig, type AxAgentContextEvent, AxAgentContextMap, type AxAgentContextMapConfig, type AxAgentContextMapOperation, type AxAgentContextMapOptions, type AxAgentContextMapSnapshot, type AxAgentContextMapUpdateResult, type AxAgentContextPressure, type AxAgentContextStage, type AxAgentDemos, type AxAgentDiscoveryPromptState, type AxAgentEvalDataset, type AxAgentEvalFunctionCall, type AxAgentEvalPrediction, type AxAgentEvalTask, type AxAgentExecutorResultPayload, type AxAgentForwardOptions, type AxAgentFunction, type AxAgentFunctionCall, type AxAgentFunctionCallRecorder, type AxAgentFunctionCollection, type AxAgentFunctionExample, type AxAgentFunctionGroup, type AxAgentFunctionModuleMeta, type AxAgentGuidanceLogEntry, type AxAgentGuidancePayload, type AxAgentGuidanceState, type AxAgentIdentity, type AxAgentInputUpdateCallback, type AxAgentJudgeEvalInput, type AxAgentJudgeEvalOutput, type AxAgentJudgeInput, type AxAgentJudgeOptions, type AxAgentJudgeOutput, type AxAgentMemoriesSearchFn, type AxAgentMemoryEntry, type AxAgentMemoryResult, type AxAgentOnContextEvent, type AxAgentOnFunctionCall, type AxAgentOptimizationTargetDescriptor, type AxAgentOptimizeOptions, type AxAgentOptimizeResult, type AxAgentOptimizeTarget, type AxAgentOptions, AxAgentProtocolCompletionSignal, type AxAgentRecursionOptions, type AxAgentRecursiveExpensiveNode, type AxAgentRecursiveFunctionCall, type AxAgentRecursiveNodeRole, type AxAgentRecursiveStats, type AxAgentRecursiveTargetId, type AxAgentRecursiveTraceNode, type AxAgentRecursiveTurn, type AxAgentRecursiveUsage, type AxAgentRuntimeCompletionState, type AxAgentRuntimeExecutionContext, type AxAgentRuntimeInputState, type AxAgentSkillResult, type AxAgentSkillsPromptState, type AxAgentSkillsSearchFn, type AxAgentState, type AxAgentStateActionLogEntry, type AxAgentStateCheckpointState, type AxAgentStateExecutorModelState, type AxAgentStateRuntimeEntry, type AxAgentStreamingForwardOptions, type AxAgentStructuredClarification, type AxAgentTestCompletionPayload, type AxAgentTestResult, type AxAgentUsage, type AxAgentUsedMemoriesCallback, type AxAgentUsedMemory, type AxAgentUsedSkill, type AxAgentUsedSkillsCallback, type AxAgentic, type AxAnyAgentic, type AxAttempt, type AxAudioFormat, type AxAudioInput, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, AxBestOfN, type AxBestOfNOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, type AxChatAudioConfig, type AxChatAudioOutput, type AxChatLogEntry, type AxChatLogMessage, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCitation, type AxCodeRuntime, type AxCodeSession, type AxCodeSessionSnapshot, type AxCodeSessionSnapshotEntry, type AxCompileOptions, AxContentProcessingError, type AxContentProcessingServices, type AxContextCacheInfo, type AxContextCacheOperation, type AxContextCacheOptions, type AxContextCacheRegistry, type AxContextCacheRegistryEntry, type AxContextFieldInput, type AxContextFieldPromptConfig, type AxContextPolicyBudget, type AxContextPolicyConfig, type AxContextPolicyPreset, type AxCostTracker, type AxCostTrackerOptions, type AxDateRange, type AxDateRangeValue, type AxDebugChatResponseUsage, AxDefaultCostTracker, type AxDiscoveryTurnSummary, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxExamples, type AxExecutorModelPolicy, type AxExecutorModelPolicyEntry, type AxField, type AxFieldOptions, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, type AxFlowBranchEvaluationData, type AxFlowCompleteData, type AxFlowDynamicContext, type AxFlowErrorData, type AxFlowExecutionPlan, type AxFlowExecutionPlanGroup, type AxFlowExecutionPlanStep, type AxFlowForwardOptions, type AxFlowLogData, type AxFlowLoggerData, type AxFlowLoggerFunction, type AxFlowOptions, type AxFlowParallelGroupCompleteData, type AxFlowParallelGroupStartData, type AxFlowStartData, type AxFlowState, type AxFlowStateDependencyAnalysis, type AxFlowStepCompleteData, type AxFlowStepStartData, type AxFlowTypedParallelBranch, type AxFlowTypedSubContext, type AxFlowable, type AxFluentFieldInfo, AxFluentFieldType, type AxForwardable, type AxFunction, type AxFunctionCallRecord, type AxFunctionCallTrace, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionProvider, type AxFunctionResult, type AxFunctionResultFormatter, AxGEPA, type AxGEPAAdapter, type AxGEPABatchEvaluation, type AxGEPABatchRow, type AxGEPABootstrapOptions, type AxGEPAComponentBanditState, AxGEPAComponentSelector, type AxGEPAComponentTarget, type AxGEPAEvaluationBatch, type AxGEPAEvaluationState, type AxGEPAOptimizationReport, type AxGEPAReflectiveTuple, type AxGEPATraceSummary, type AxGEPATraceSummaryCall, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenInput, type AxGenMetricsInstruments, type AxGenOut, type AxGenOutput, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, type AxIField, type AxInputFunctionType, AxJSRuntime, type AxJSRuntimeNodePermissionAllowlist, type AxJSRuntimeOutputMode, AxJSRuntimePermission, type AxJSRuntimeResourceLimits, type AxJudgeForwardOptions, type AxJudgeOptions, type AxLlmQueryBudgetState, type AxLlmQueryPromptMode, type AxLoggerData, type AxLoggerFunction, type AxMCPBlobResourceContents, AxMCPClient, type AxMCPEmbeddedResource, type AxMCPFunctionDescription, AxMCPHTTPSSETransport, type AxMCPImageContent, type AxMCPInitializeParams, type AxMCPInitializeResult, type AxMCPJSONRPCErrorResponse, type AxMCPJSONRPCNotification, type AxMCPJSONRPCRequest, type AxMCPJSONRPCResponse, type AxMCPJSONRPCSuccessResponse, type AxMCPOAuthOptions, type AxMCPPrompt, type AxMCPPromptArgument, type AxMCPPromptGetResult, type AxMCPPromptMessage, type AxMCPPromptsListResult, type AxMCPResource, type AxMCPResourceReadResult, type AxMCPResourceTemplate, type AxMCPResourceTemplatesListResult, type AxMCPResourcesListResult, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPTextContent, type AxMCPTextResourceContents, type AxMCPToolsListResult, type AxMCPTransport, AxMediaNotSupportedError, AxMemory, type AxMemoryData, type AxMemoryMessageValue, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, type AxMultiProviderConfig, AxMultiServiceRouter, type AxNamedProgramInstance, type AxOptimizableComponent, type AxOptimizableValidator, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizedProgram, AxOptimizedProgramImpl, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerLoggerData, type AxOptimizerLoggerFunction, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramForwardOptionsWithModels, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramStreamingForwardOptionsWithModels, type AxProgramTrace, type AxProgramUsage, type AxProgrammable, type AxPromptMetrics, AxPromptTemplate, type AxPromptTemplateOptions, type AxProviderMetadata, AxProviderRouter, type AxRLMConfig, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, AxRefine, AxRefineError, type AxRefineOptions, type AxRefineStrategy, type AxRenderedPrompt, type AxResolvedContextPolicy, type AxResolvedExecutorModelPolicy, type AxResolvedExecutorModelPolicyEntry, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewardFn, type AxRewardFnArgs, type AxRolloutTrace, type AxRoutingResult, type AxRuntimeCallableFormatArgs, type AxRuntimeLanguageInfo, type AxRuntimePrimitive, type AxRuntimePrimitiveExample, type AxRuntimePrimitiveOverrideMap, type AxRuntimePrimitiveSignature, type AxRuntimePrimitiveStage, type AxSamplePickerOptions, type AxSelfTuningConfig, type AxSerializedOptimizedProgram, type AxSetExamplesOptions, AxSignature, AxSignatureBuilder, type AxSignatureConfig, type AxSignatureInput, type AxSpeechConfig, type AxSpeechRequest, type AxSpeechResponse, type AxStageDefinitionBuildOptions, type AxStageOptions, type AxStepContext, type AxStepHooks, type AxStepUsage, AxStopFunctionCallException, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, type AxStreamingGuard, AxStreamingGuardError, AxStringUtil, AxSynth, type AxSynthExample, type AxSynthOptions, type AxSynthResult, type AxSynthesizerInit, type AxSynthesizerOptions, type AxSynthesizerRole, AxTestPrompt, type AxThoughtBlockItem, AxTokenLimitError, type AxTokenUsage, type AxTranscriptionRequest, type AxTranscriptionResponse, type AxTranscriptionSegment, type AxTunable, type AxTypedExample, type AxUsable, type AxWorkerRuntimeConfig, agent, ai, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGoogleGeminiLiveAudioDefaultConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIGrokVoiceDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOpenAIAudioDefaultConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIRealtimeDefaultConfig, axAIOpenAIRealtimeTranscriptionDefaultConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAnalyzeChatPromptRequirements, axAnalyzeRequestRequirements, axApplyOpenAIChatAudioRequest, axAudioFormatFromMimeType, axAudioInputFilename, axAudioInputToBlob, axAudioMimeType, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axBuildDistillerDefinition, axBuildExecutorDefinition, axBuildResponderDefinition, axCheckMetricsHealth, axConcatBase64, axCreateDefaultColorLogger, axCreateDefaultOptimizerColorLogger, axCreateDefaultOptimizerTextLogger, axCreateDefaultTextLogger, axCreateFlowColorLogger, axCreateFlowTextLogger, axCreateGeminiLiveAudioApi, axCreateGrokRealtimeApi, axCreateJSRuntime, axCreateOpenAIRealtimeApi, axDefaultFlowLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axDeserializeOptimizedProgram, axFetchJsonSpeech, axFetchMultipartTranscription, axGetCompatibilityReport, axGetFormatCompatibility, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGetProvidersWithMediaSupport, axGetSupportedAIModels, axGlobals, axGoogleGeminiLiveAudioDefaults, axIsAudioOutputEnabled, axIsGeminiLiveAudioModel, axIsGrokVoiceModel, axIsOpenAIChatAudioModel, axIsOpenAIRealtimeModel, axIsOpenAIRealtimeTranscriptionModel, axMapGeminiLiveAudioPart, axMapOpenAIChatAudioDelta, axMapOpenAIChatAudioResponse, axMapOpenAIInputAudioPart, axMergeChatAudioConfig, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axNormalizeOpenAIUsage, axNormalizeTranscriptionResponse, axOpenAIChatAudioDefaults, axOptimizableValidators, axProcessContentForProvider, axResolveGeminiLiveAudioConfig, axResolveGrokRealtimeAudioConfig, axResolveOpenAIChatAudioConfig, axResolveOpenAIRealtimeAudioConfig, axRuntimePrimitives, axScoreProvidersForRequest, axSelectOptimalProvider, axSerializeOptimizedProgram, axShouldUseGeminiLiveAudio, axShouldUseGrokRealtime, axShouldUseOpenAIRealtime, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, axValidateGeminiLiveAudioInput, axValidateProviderCapabilities, axWorkerRuntime, bestOfN, f, flow, fn, refine, s };