@ax-llm/ax 13.0.23 → 14.0.0

package/index.d.cts

@@ -74,6 +74,83 @@ declare class AxAIRefusalError extends Error {
     constructor(refusalMessage: string, model?: string | undefined, requestId?: string | undefined);
     toString(): string;
 }
+/**
+ * Error thrown when an AI provider doesn't support a required media type.
+ *
+ * This error is thrown during content processing when a provider cannot handle
+ * a specific media type and no suitable fallback mechanism is available or configured.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await textOnlyProvider.chat(imageRequest);
+ * } catch (error) {
+ *   if (error instanceof AxMediaNotSupportedError) {
+ *     console.log(`${error.mediaType} not supported by ${error.provider}`);
+ *     if (error.fallbackAvailable) {
+ *       console.log('Consider using content processing services');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class AxMediaNotSupportedError extends Error {
+    readonly mediaType: string;
+    readonly provider: string;
+    readonly fallbackAvailable: boolean;
+    /** ISO timestamp when the error occurred */
+    readonly timestamp: string;
+    /** Unique identifier for this error instance */
+    readonly errorId: string;
+    /**
+     * Creates a new media not supported error.
+     *
+     * @param mediaType - The type of media that is not supported (e.g., 'Images', 'Audio')
+     * @param provider - The name of the AI provider that doesn't support the media type
+     * @param fallbackAvailable - Whether fallback processing options are available
+     */
+    constructor(mediaType: string, provider: string, fallbackAvailable?: boolean);
+    toString(): string;
+}
+/**
+ * Error thrown when content processing/transformation fails.
+ *
+ * This error wraps underlying failures from content processing services like
+ * image-to-text, audio transcription, file text extraction, or URL content fetching.
+ * It provides context about what type of content was being processed and at which step.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await axProcessContentForProvider(content, provider, {
+ *     imageToText: imageService.analyze
+ *   });
+ * } catch (error) {
+ *   if (error instanceof AxContentProcessingError) {
+ *     console.log(`Failed processing ${error.contentType} during ${error.processingStep}`);
+ *     console.log('Original error:', error.originalError.message);
+ *   }
+ * }
+ * ```
+ */
+declare class AxContentProcessingError extends Error {
+    readonly originalError: Error;
+    readonly contentType: string;
+    readonly processingStep: string;
+    /** ISO timestamp when the error occurred */
+    readonly timestamp: string;
+    /** Unique identifier for this error instance */
+    readonly errorId: string;
+    /**
+     * Creates a new content processing error.
+     *
+     * @param originalError - The underlying error that caused the processing failure
+     * @param contentType - The type of content being processed (e.g., 'image', 'audio', 'file')
+     * @param processingStep - The specific processing step that failed (e.g., 'vision analysis', 'transcription')
+     */
+    constructor(originalError: Error, contentType: string, processingStep: string);
+    toString(): string;
+}
 
 type AxAIInputModelList<TModel, TEmbedModel, TModelKey> = (AxAIModelListBase<TModelKey> & {
     isInternal?: boolean;
@@ -109,6 +186,10 @@ type AxTokenUsage = {
     completionTokens: number;
     totalTokens: number;
     thoughtsTokens?: number;
+    reasoningTokens?: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    serviceTier?: 'standard' | 'priority' | 'batch';
 };
 type AxModelConfig = {
     maxTokens?: number;
@@ -168,9 +249,23 @@ type AxChatResponseResult = {
             url: string;
             title?: string;
             description?: string;
+            license?: string;
+            publicationDate?: string;
+            snippet?: string;
+            confidenceScore?: number;
         };
     }[];
     finishReason?: 'stop' | 'length' | 'function_call' | 'content_filter' | 'error';
+    logprobs?: {
+        content?: {
+            token: string;
+            logprob: number;
+            topLogprobs?: {
+                token: string;
+                logprob: number;
+            }[];
+        }[];
+    };
 };
 type AxModelUsage = {
     ai: string;
@@ -210,11 +305,43 @@ type AxChatRequest<TModel = string> = {
             image: string;
             details?: 'high' | 'low' | 'auto';
             cache?: boolean;
+            /** Optimization preference for image processing */
+            optimize?: 'quality' | 'size' | 'auto';
+            /** Fallback text description when images aren't supported */
+            altText?: string;
         } | {
             type: 'audio';
             data: string;
-            format?: 'wav';
+            format?: 'wav' | 'mp3' | 'ogg';
             cache?: boolean;
+            /** Pre-transcribed text content for fallback */
+            transcription?: string;
+            /** Duration of audio in seconds */
+            duration?: number;
+        } | {
+            /** File content type */
+            type: 'file';
+            /** File data as base64 or file URL */
+            data: string;
+            /** Original filename */
+            filename: string;
+            /** MIME type of the file */
+            mimeType: string;
+            cache?: boolean;
+            /** Pre-extracted text content for fallback */
+            extractedText?: string;
+        } | {
+            /** URL/Link content type */
+            type: 'url';
+            /** The URL to fetch content from */
+            url: string;
+            cache?: boolean;
+            /** Pre-fetched content for providers without web access */
+            cachedContent?: string;
+            /** Page title for context */
+            title?: string;
+            /** Page description for context */
+            description?: string;
         })[];
     } | {
         role: 'assistant';
@@ -236,6 +363,30 @@ type AxChatRequest<TModel = string> = {
         functionId: string;
         cache?: boolean;
     })[];
+    /** Provider capability preferences and requirements */
+    capabilities?: {
+        /** Whether the request requires image support */
+        requiresImages?: boolean;
+        /** Whether the request requires audio support */
+        requiresAudio?: boolean;
+        /** Whether the request requires file support */
+        requiresFiles?: boolean;
+        /** Whether the request requires web search capabilities */
+        requiresWebSearch?: boolean;
+        /** How to handle unsupported content types */
+        fallbackBehavior?: 'error' | 'degrade' | 'skip';
+    };
+    /** Content processing preferences and hints */
+    processing?: {
+        /** Whether to apply image compression */
+        imageCompression?: boolean;
+        /** Whether to apply audio transcription */
+        audioTranscription?: boolean;
+        /** Whether to extract text from files */
+        fileTextExtraction?: boolean;
+        /** Whether to fetch content from URLs */
+        urlContentFetching?: boolean;
+    };
     functions?: Readonly<{
         name: string;
         description: string;
@@ -400,6 +551,60 @@ interface AxAIFeatures {
     functionCot?: boolean;
     hasThinkingBudget?: boolean;
     hasShowThoughts?: boolean;
+    /** Enhanced media capability specifications */
+    media: {
+        /** Image processing capabilities */
+        images: {
+            /** Whether the provider supports image inputs */
+            supported: boolean;
+            /** Supported image MIME types (e.g., ['image/jpeg', 'image/png']) */
+            formats: string[];
+            /** Maximum image size in bytes */
+            maxSize?: number;
+            /** Supported detail/quality levels for image processing */
+            detailLevels?: ('high' | 'low' | 'auto')[];
+        };
+        /** Audio processing capabilities */
+        audio: {
+            /** Whether the provider supports audio inputs */
+            supported: boolean;
+            /** Supported audio formats (e.g., ['wav', 'mp3']) */
+            formats: string[];
+            /** Maximum audio duration in seconds */
+            maxDuration?: number;
+        };
+        /** File processing capabilities */
+        files: {
+            /** Whether the provider supports file inputs */
+            supported: boolean;
+            /** Supported file MIME types (e.g., ['application/pdf', 'text/plain']) */
+            formats: string[];
+            /** Maximum file size in bytes */
+            maxSize?: number;
+            /** How files are uploaded to the provider */
+            uploadMethod: 'inline' | 'upload' | 'cloud' | 'none';
+        };
+        /** URL and web content capabilities */
+        urls: {
+            /** Whether the provider supports URL inputs */
+            supported: boolean;
+            /** Whether the provider can perform web searches */
+            webSearch: boolean;
+            /** Whether the provider can fetch web page content */
+            contextFetching: boolean;
+        };
+    };
+    /** Content caching capabilities */
+    caching: {
+        /** Whether the provider supports content caching */
+        supported: boolean;
+        /** Types of caching available */
+        types: ('ephemeral' | 'persistent')[];
+    };
+    /** Whether the provider supports thinking/reasoning modes */
+    thinking: boolean;
+    /** Whether the provider supports multi-turn conversations */
+    multiTurn: boolean;
 }
 interface AxBaseAIArgs<TModel, TEmbedModel, TModelKey> {
     name: string;
@@ -1097,6 +1302,307 @@ declare class AxBalancer<TServices extends readonly AxAIService<any, any, any>[]
     getLogger(): AxLoggerFunction;
 }
 
+/**
+ * Configuration options for content processing and fallback behavior
+ */
+interface ProcessingOptions {
+    /** How to handle unsupported content types: 'error' throws, 'degrade' converts to text, 'skip' omits */
+    fallbackBehavior?: 'error' | 'degrade' | 'skip';
+    /** Service to convert images to text descriptions */
+    imageToText?: (imageData: string) => Promise<string>;
+    /** Service to convert audio to text transcriptions */
+    audioToText?: (audioData: string, format?: string) => Promise<string>;
+    /** Service to extract text from files */
+    fileToText?: (fileData: string, mimeType: string) => Promise<string>;
+    /** Service to fetch and extract text from URLs */
+    urlToText?: (url: string) => Promise<string>;
+}
+/**
+ * Represents processed content that has been converted to text format
+ */
+interface ProcessedContent {
+    /** Content type after processing (always 'text') */
+    type: 'text';
+    /** The processed text content */
+    text: string;
+}
+/**
+ * Indicates what types of media content are present in a request
+ */
+interface MediaRequirements {
+    /** Whether the content includes images */
+    hasImages: boolean;
+    /** Whether the content includes audio */
+    hasAudio: boolean;
+    /** Whether the content includes files */
+    hasFiles: boolean;
+    /** Whether the content includes URLs */
+    hasUrls: boolean;
+}
+/**
+ * Processes content for a specific AI provider, handling unsupported media types.
+ *
+ * This function takes mixed content (text, images, audio, files, URLs) and transforms
+ * it to formats supported by the target provider. Unsupported content types are
+ * handled according to the fallback behavior:
+ * - 'error': Throws AxMediaNotSupportedError
+ * - 'degrade': Converts to text using fallback services or alt text
+ * - 'skip': Omits the unsupported content
+ *
+ * @param content - The content to process (string, object, or array of content items)
+ * @param provider - The target AI service provider
+ * @param options - Processing options including fallback behavior and conversion services
+ * @returns Promise resolving to array of processed content items (all converted to text)
+ * @throws AxMediaNotSupportedError when fallbackBehavior is 'error' and content is unsupported
+ * @throws AxContentProcessingError when a conversion service fails
+ *
+ * @example
+ * ```typescript
+ * const processed = await axProcessContentForProvider(
+ *   [
+ *     { type: 'text', text: 'Analyze this:' },
+ *     { type: 'image', image: 'base64...', altText: 'Chart showing sales data' }
+ *   ],
+ *   textOnlyProvider,
+ *   {
+ *     fallbackBehavior: 'degrade',
+ *     imageToText: async (data) => await visionService.describe(data)
+ *   }
+ * );
+ * // Result: [{ type: 'text', text: 'Analyze this:' }, { type: 'text', text: 'Chart showing sales data' }]
+ * ```
+ */
+declare function axProcessContentForProvider(content: any, provider: AxAIService, options?: ProcessingOptions): Promise<ProcessedContent[]>;
+/**
+ * Analyzes a chat prompt to determine what media types it contains.
+ *
+ * Scans through chat messages to identify the types of media content present,
+ * which can be used for provider capability matching and routing decisions.
+ *
+ * @param chatPrompt - Array of chat messages to analyze
+ * @returns Object indicating which media types are present in the chat prompt
+ *
+ * @example
+ * ```typescript
+ * const requirements = axAnalyzeChatPromptRequirements([
+ *   {
+ *     role: 'user',
+ *     content: [
+ *       { type: 'text', text: 'Analyze this:' },
+ *       { type: 'image', image: 'base64...' },
+ *       { type: 'file', filename: 'report.pdf' }
+ *     ]
+ *   }
+ * ]);
+ * // Result: { hasImages: true, hasAudio: false, hasFiles: true, hasUrls: false }
+ * ```
+ */
+declare function axAnalyzeChatPromptRequirements(chatPrompt: any[]): MediaRequirements;
+
+/**
+ * Represents a provider's compatibility score for a specific request
+ */
+interface ProviderCapabilityScore {
+    /** The AI service provider */
+    provider: AxAIService;
+    /** Numerical score based on capability match (higher is better) */
+    score: number;
+    /** List of capabilities the provider is missing for this request */
+    missingCapabilities: string[];
+    /** List of capabilities the provider supports for this request */
+    supportedCapabilities: string[];
+}
+/**
+ * Result of validating whether a provider can handle a request
+ */
+interface CapabilityValidationResult {
+    /** Whether the provider fully supports the request */
+    isSupported: boolean;
+    /** List of capabilities the provider is missing */
+    missingCapabilities: string[];
+    /** Non-critical issues or limitations */
+    warnings: string[];
+    /** Suggested alternatives for missing capabilities */
+    alternatives: string[];
+}
+/**
+ * Analyzes a chat request to determine what capabilities it requires from AI providers.
+ *
+ * This function examines the request content to identify:
+ * - Media types (images, audio, files, URLs)
+ * - Function calling requirements
+ * - Streaming requirements
+ * - Caching requirements
+ * - Token usage estimation
+ *
+ * @param request - The chat request to analyze
+ * @returns Object containing detailed capability requirements and token estimation
+ *
+ * @example
+ * ```typescript
+ * const requirements = axAnalyzeRequestRequirements({
+ *   chatPrompt: [{
+ *     role: 'user',
+ *     content: [
+ *       { type: 'text', text: 'Analyze this image:' },
+ *       { type: 'image', image: 'base64...', details: 'high' }
+ *     ]
+ *   }]
+ * });
+ *
+ * console.log(requirements.hasImages); // true
+ * console.log(requirements.estimatedTokens); // ~95
+ * ```
+ */
+declare function axAnalyzeRequestRequirements(request: AxChatRequest): MediaRequirements & {
+    requiresFunctions: boolean;
+    requiresStreaming: boolean;
+    requiresCaching: boolean;
+    contentTypes: Set<string>;
+    estimatedTokens: number;
+};
+/**
+ * Validates whether an AI provider can handle a request with specific requirements.
+ *
+ * Compares the provider's feature set against the analyzed request requirements
+ * to determine compatibility, missing capabilities, and potential issues.
+ *
+ * @param provider - The AI service provider to validate
+ * @param requirements - Requirements object from axAnalyzeRequestRequirements()
+ * @returns Validation result with support status, missing capabilities, and alternatives
+ *
+ * @example
+ * ```typescript
+ * const requirements = axAnalyzeRequestRequirements(request);
+ * const validation = axValidateProviderCapabilities(openaiProvider, requirements);
+ *
+ * if (!validation.isSupported) {
+ *   console.log('Missing:', validation.missingCapabilities);
+ *   console.log('Try:', validation.alternatives);
+ * }
+ * ```
+ */
+declare function axValidateProviderCapabilities(provider: AxAIService, requirements: ReturnType<typeof axAnalyzeRequestRequirements>): CapabilityValidationResult;
+/**
+ * Scores multiple AI providers based on how well they meet request requirements.
+ *
+ * Uses a weighted scoring system where providers earn points for supported capabilities:
+ * - Base functionality: +10 points
+ * - Media support (images/audio/files/URLs): +25 points each
+ * - Core features (functions/streaming/caching): +8-15 points each
+ * - Missing critical capabilities: -10 points each
+ * - Bonus points for advanced features (large file support, persistent caching, etc.)
+ *
+ * @param providers - Array of AI service providers to score
+ * @param requirements - Requirements object from axAnalyzeRequestRequirements()
+ * @returns Array of scored providers sorted by score (highest first)
+ *
+ * @example
+ * ```typescript
+ * const requirements = axAnalyzeRequestRequirements(request);
+ * const scores = axScoreProvidersForRequest([openai, gemini, cohere], requirements);
+ *
+ * console.log(`Best: ${scores[0].provider.getName()} (${scores[0].score} points)`);
+ * console.log(`Supports: ${scores[0].supportedCapabilities.join(', ')}`);
+ * ```
+ */
+declare function axScoreProvidersForRequest(providers: AxAIService[], requirements: ReturnType<typeof axAnalyzeRequestRequirements>): ProviderCapabilityScore[];
+/**
+ * Automatically selects the optimal AI provider for a given request.
+ *
+ * Analyzes the request requirements, scores available providers, and returns
+ * the best match based on capability compatibility and scoring algorithm.
+ *
+ * @param request - The chat request to find a provider for
+ * @param availableProviders - Array of available AI service providers
+ * @param options - Selection options
+ * @param options.requireExactMatch - Only return providers with full capability support
+ * @param options.allowDegradation - Allow providers that require content processing fallbacks
+ * @returns The optimal AI service provider
+ * @throws Error if no suitable provider found or requirements not met
+ *
+ * @example
+ * ```typescript
+ * // Automatic selection with degradation allowed
+ * const provider = axSelectOptimalProvider(
+ *   multiModalRequest,
+ *   [openai, gemini, cohere],
+ *   { allowDegradation: true }
+ * );
+ *
+ * // Strict matching - must support all features natively
+ * const provider = axSelectOptimalProvider(
+ *   imageRequest,
+ *   [openai, gemini],
+ *   { requireExactMatch: true }
+ * );
+ * ```
+ */
+declare function axSelectOptimalProvider(request: AxChatRequest, availableProviders: AxAIService[], options?: {
+    requireExactMatch?: boolean;
+    allowDegradation?: boolean;
+}): AxAIService;
+/**
+ * Generates a comprehensive compatibility report for a request across all providers.
+ *
+ * Provides detailed analysis including requirement breakdown, provider scoring,
+ * recommendations, and human-readable compatibility summary.
+ *
+ * @param request - The chat request to analyze
+ * @param availableProviders - Array of available AI service providers
+ * @returns Comprehensive compatibility report with analysis and recommendations
+ *
+ * @example
+ * ```typescript
+ * const report = axGetCompatibilityReport(request, [openai, gemini, cohere]);
+ *
+ * console.log(report.summary); // "OpenAI supports 4/4 requirements (100% compatibility)"
+ * console.log('Requirements:', report.requirements);
+ *
+ * for (const score of report.providerScores) {
+ *   console.log(`${score.provider.getName()}: ${score.score} points`);
+ *   console.log(`  Missing: ${score.missingCapabilities.join(', ')}`);
+ * }
+ * ```
+ */
+declare function axGetCompatibilityReport(request: AxChatRequest, availableProviders: AxAIService[]): {
+    requirements: ReturnType<typeof axAnalyzeRequestRequirements>;
+    providerScores: ProviderCapabilityScore[];
+    recommendedProvider: AxAIService | null;
+    summary: string;
+};
+/**
+ * Filters providers that support a specific media type.
+ *
+ * @param providers - Array of AI service providers to filter
+ * @param mediaType - The media type to check support for
+ * @returns Array of providers that support the specified media type
+ *
+ * @example
+ * ```typescript
+ * const imageProviders = axGetProvidersWithMediaSupport(allProviders, 'images');
+ * console.log(`${imageProviders.length} providers support images`);
+ * ```
+ */
+declare function axGetProvidersWithMediaSupport(providers: AxAIService[], mediaType: 'images' | 'audio' | 'files' | 'urls'): AxAIService[];
+/**
+ * Analyzes format compatibility across providers for a specific media type.
+ *
+ * @param providers - Array of AI service providers to analyze
+ * @param mediaType - The media type to check format support for
+ * @returns Object mapping each supported format to the providers that support it
+ *
+ * @example
+ * ```typescript
+ * const compatibility = axGetFormatCompatibility(allProviders, 'images');
+ * console.log('JPEG support:', compatibility['image/jpeg']?.map(p => p.getName()));
+ * console.log('PNG support:', compatibility['image/png']?.map(p => p.getName()));
+ * ```
+ */
+declare function axGetFormatCompatibility(providers: AxAIService[], mediaType: 'images' | 'audio' | 'files'): {
+    [format: string]: AxAIService[];
+};
+
 /**
  * Cohere: Models for text generation
  */
@@ -1685,10 +2191,7 @@ declare class AxMockAIService<TModelKey> implements AxAIService<unknown, unknown
     getLastUsedModelConfig(): AxModelConfig | undefined;
     getName(): string;
     getId(): string;
-    getFeatures(_model?: string): {
-        functions: boolean;
-        streaming: boolean;
-    };
+    getFeatures(_model?: string): AxAIFeatures;
     getModelList(): AxAIModelList<TModelKey> | undefined;
     getMetrics(): AxAIServiceMetrics;
     chat(req: Readonly<AxChatRequest<unknown>>, _options?: Readonly<AxAIServiceOptions>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
@@ -1751,11 +2254,7 @@ declare class AxMultiServiceRouter<TServices extends readonly (AxAIService | AxA
      * If a model key is provided, delegate to the corresponding service's features.
      * Otherwise, returns a default feature set.
      */
-    getFeatures(model?: TModelKey): {
-        functions: boolean;
-        streaming: boolean;
-        functionCot?: boolean;
-    };
+    getFeatures(model?: TModelKey): AxAIFeatures;
     /**
      * Returns aggregated metrics from the underlying service.
      * Uses the metrics from the last service that was used,
@@ -2453,6 +2952,235 @@ declare class AxAIReka<TModelKey> extends AxBaseAI<AxAIRekaModel, undefined, AxA
  */
 declare const axModelInfoReka: AxModelInfo[];
 
+/**
+ * Services for converting unsupported content types to text or optimized formats
+ */
+interface AxContentProcessingServices {
+    /** Service to convert images to text descriptions */
+    imageToText?: (imageData: string) => Promise<string>;
+    /** Service to convert audio to text transcriptions */
+    audioToText?: (audioData: string, format?: string) => Promise<string>;
+    /** Service to extract text from files */
+    fileToText?: (fileData: string, mimeType: string) => Promise<string>;
+    /** Service to fetch and extract text from URLs */
+    urlToText?: (url: string) => Promise<string>;
+    /** Service to optimize images for size/quality */
+    imageOptimization?: (imageData: string, options: OptimizationOptions) => Promise<string>;
+}
+/**
+ * Options for image optimization processing
+ */
+interface OptimizationOptions {
+    /** Image quality (0-100) */
+    quality?: number;
+    /** Maximum file size in bytes */
+    maxSize?: number;
+    /** Target image format */
+    format?: 'jpeg' | 'png' | 'webp';
+}
+/**
+ * Configuration for multi-provider routing with fallback capabilities
+ */
+interface AxMultiProviderConfig {
+    /** Provider hierarchy for routing */
+    providers: {
+        /** Primary provider to try first */
+        primary: AxAIService;
+        /** Alternative providers for fallback */
+        alternatives: AxAIService[];
+    };
+    /** Routing behavior configuration */
+    routing: {
+        /** Order of preferences when selecting providers */
+        preferenceOrder: ('capability' | 'cost' | 'speed' | 'quality')[];
+        /** Capability matching requirements */
+        capability: {
+            /** Only use providers with full capability support */
+            requireExactMatch: boolean;
+            /** Allow providers that require content processing fallbacks */
+            allowDegradation: boolean;
+        };
+    };
+    /** Content processing services for unsupported media types */
+    processing: AxContentProcessingServices;
+}
+/**
+ * Result of the routing process including provider selection and processing information
+ */
+interface AxRoutingResult {
+    /** The selected AI service provider */
+    provider: AxAIService;
+    /** List of content processing steps that were applied */
+    processingApplied: string[];
+    /** List of capability degradations that occurred */
+    degradations: string[];
+    /** Non-critical warnings about the routing decision */
+    warnings: string[];
+}
+/**
+ * Multi-provider router that automatically selects optimal AI providers and handles content processing.
+ *
+ * The router analyzes requests to determine capability requirements, scores available providers,
+ * and automatically handles content transformation for unsupported media types. It provides
+ * graceful degradation and fallback mechanisms for robust multi-modal AI applications.
+ *
+ * @example
+ * ```typescript
+ * const router = new AxProviderRouter({
+ *   providers: {
+ *     primary: openaiProvider,
+ *     alternatives: [geminiProvider, cohereProvider]
+ *   },
+ *   routing: {
+ *     preferenceOrder: ['capability', 'quality'],
+ *     capability: {
+ *       requireExactMatch: false,
+ *       allowDegradation: true
+ *     }
+ *   },
+ *   processing: {
+ *     imageToText: async (data) => await visionService.describe(data),
+ *     audioToText: async (data) => await speechService.transcribe(data)
+ *   }
+ * });
+ *
+ * const result = await router.chat(multiModalRequest);
+ * console.log(`Used: ${result.routing.provider.getName()}`);
+ * ```
+ */
+declare class AxProviderRouter {
+    private providers;
+    private processingServices;
+    private config;
+    /**
+     * Creates a new provider router with the specified configuration.
+     *
+     * @param config - Router configuration including providers, routing preferences, and processing services
+     */
+    constructor(config: AxMultiProviderConfig);
+    /**
+     * Routes a chat request to the most appropriate provider with automatic content processing.
+     *
+     * This method analyzes the request, selects the optimal provider, preprocesses content
+     * for compatibility, and executes the request with fallback support.
+     *
+     * @param request - The chat request to process
+     * @param options - Extended options including fallback providers and routing preferences
+     * @param options.fallbackProviders - Additional providers to try if primary selection fails
+     * @param options.processingOptions - Content processing options and conversion services
+     * @param options.routingOptions - Provider selection and routing behavior options
+     * @param options.routingOptions.requireExactMatch - Only use providers with full capability support
+     * @param options.routingOptions.allowDegradation - Allow content processing for unsupported types
+     * @param options.routingOptions.maxRetries - Maximum number of fallback providers to try
+     * @returns Promise resolving to the AI response and routing information
+     * @throws AxMediaNotSupportedError when no suitable provider can handle the request
+     *
+     * @example
+     * ```typescript
+     * const result = await router.chat(
+     *   { chatPrompt: [{ role: 'user', content: [{ type: 'image', image: '...' }] }] },
+     *   {
+     *     processingOptions: { fallbackBehavior: 'degrade' },
+     *     routingOptions: { allowDegradation: true }
+     *   }
+     * );
+     *
+     * console.log(`Provider: ${result.routing.provider.getName()}`);
+     * console.log(`Processing applied: ${result.routing.processingApplied}`);
+     * ```
+     */
+    chat(request: AxChatRequest, options?: AxAIServiceOptions & {
+        fallbackProviders?: AxAIService[];
+        processingOptions?: ProcessingOptions;
+        routingOptions?: {
+            requireExactMatch?: boolean;
+            allowDegradation?: boolean;
+            maxRetries?: number;
+        };
+    }): Promise<{
+        response: AxChatResponse | ReadableStream<AxChatResponse>;
+        routing: AxRoutingResult;
+    }>;
+    /**
+     * Preprocesses request content for the target provider
+     */
+    private preprocessRequest;
+    /**
+     * Selects provider with graceful degradation
+     */
+    private selectProviderWithDegradation;
+    /**
+     * Tries fallback providers when primary provider fails
+     */
+    private tryFallbackProviders;
+    /**
+     * Gets routing recommendation without executing the request.
+     *
+     * Analyzes the request and returns routing information including which provider
+     * would be selected, what processing would be applied, and any degradations or warnings.
+     *
+     * @param request - The chat request to analyze
+     * @returns Promise resolving to routing result with provider selection and processing info
+     *
+     * @example
+     * ```typescript
+     * const recommendation = await router.getRoutingRecommendation(request);
+     * console.log(`Would use: ${recommendation.provider.getName()}`);
+     * console.log(`Degradations: ${recommendation.degradations.join(', ')}`);
+     * ```
+     */
+    getRoutingRecommendation(request: AxChatRequest): Promise<AxRoutingResult>;
+    /**
+     * Validates whether the configured providers can handle a specific request.
+     *
+     * Performs pre-flight validation to check if the request can be successfully
+     * processed by available providers, identifies potential issues, and provides
+     * recommendations for improving compatibility.
+     *
+     * @param request - The chat request to validate
+     * @returns Promise resolving to validation result with handling capability and recommendations
+     *
+     * @example
+     * ```typescript
+     * const validation = await router.validateRequest(request);
+     * if (!validation.canHandle) {
+     *   console.log('Issues:', validation.issues);
+     *   console.log('Recommendations:', validation.recommendations);
+     * }
+     * ```
+     */
+    validateRequest(request: AxChatRequest): Promise<{
+        canHandle: boolean;
+        issues: string[];
+        recommendations: string[];
+    }>;
+    /**
+     * Gets detailed statistics about the router's provider capabilities.
+     *
+     * Returns information about available providers, their supported capabilities,
+     * and routing recommendations for analysis and debugging purposes.
+     *
+     * @returns Object containing provider statistics and capability matrix
+     *
+     * @example
+     * ```typescript
+     * const stats = router.getRoutingStats();
+     * console.log(`Total providers: ${stats.totalProviders}`);
+     * console.log('Capabilities:');
+     * for (const [capability, providers] of Object.entries(stats.capabilityMatrix)) {
+     *   console.log(`  ${capability}: ${providers.join(', ')}`);
+     * }
+     * ```
+     */
+    getRoutingStats(): {
+        totalProviders: number;
+        capabilityMatrix: {
+            [capability: string]: string[];
+        };
+        recommendedProvider: string;
+    };
+}
+
 type TogetherAIConfig = AxAIOpenAIConfig<string, unknown>;
 declare const axAITogetherDefaultConfig: () => TogetherAIConfig;
 type AxAITogetherArgs<TModelKey> = AxAIOpenAIArgs<'together', string, unknown, TModelKey>;
@@ -2718,16 +3446,45 @@ type ExtractModelKeysAndValues<T> = T extends readonly {
 type InferTModelKey<T> = T extends {
     models: infer M;
 } ? ExtractModelKeysAndValues<M> : string;
+/**
+ * Factory function for creating AxAI instances with type safety.
+ * This is the recommended way to create AxAI instances instead of using the constructor.
+ *
+ * @param options - Configuration options for the AI service
+ * @returns A properly typed AxAI instance
+ *
+ * @example
+ * ```typescript
+ * const ai = ai({
+ *   name: 'openai',
+ *   apiKey: process.env.OPENAI_APIKEY!
+ * });
+ * ```
+ */
+declare function ai<const T extends AxAIArgs<any>>(options: T): AxAI<InferTModelKey<T>>;
 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>>);
     getName(): string;
     getId(): string;
-    getFeatures(model?: string): {
-        functions: boolean;
-        streaming: boolean;
-    };
+    getFeatures(model?: string): AxAIFeatures;
     getModelList(): AxAIModelList<TModelKey> | undefined;
     getLastUsedChatModel(): any;
     getLastUsedEmbedModel(): any;
@@ -2908,61 +3665,6 @@ interface AxAIMemory {
     rewindToTag(name: string, sessionId?: string): AxMemoryData;
 }
 
-interface AxField {
-    name: string;
-    title?: string;
-    description?: string;
-    type?: {
-        name: 'string' | 'number' | 'boolean' | 'json' | 'image' | 'audio' | 'date' | 'datetime' | 'class' | 'code';
-        isArray?: boolean;
-        options?: string[];
-    };
-    isOptional?: boolean;
-    isInternal?: boolean;
-}
-type AxIField = Omit<AxField, 'title'> & {
-    title: string;
-};
-interface AxSignatureConfig {
-    description?: string;
-    inputs: readonly AxField[];
-    outputs: readonly AxField[];
-}
-declare class AxSignature {
-    private description?;
-    private inputFields;
-    private outputFields;
-    private sigHash;
-    private sigString;
-    private validatedAtHash?;
-    constructor(signature?: Readonly<AxSignature | string | AxSignatureConfig>);
-    private parseParsedField;
-    private parseField;
-    setDescription: (desc: string) => void;
-    addInputField: (field: Readonly<AxField>) => void;
-    addOutputField: (field: Readonly<AxField>) => void;
-    setInputFields: (fields: readonly AxField[]) => void;
-    setOutputFields: (fields: readonly AxField[]) => void;
-    getInputFields: () => Readonly<AxIField[]>;
-    getOutputFields: () => Readonly<AxIField[]>;
-    getDescription: () => string | undefined;
-    private invalidateValidationCache;
-    private toTitle;
-    toJSONSchema: () => AxFunctionJSONSchema;
-    private updateHashLight;
-    private updateHash;
-    private validateSignatureConsistency;
-    validate: () => boolean;
-    hash: () => string;
-    toString: () => string;
-    toJSON: () => {
-        id: string;
-        description: string | undefined;
-        inputFields: AxIField[];
-        outputFields: AxIField[];
-    };
-}
-
 declare class AxMemory implements AxAIMemory {
     private memories;
     private defaultMemory;
@@ -2993,11 +3695,29 @@ declare class AxMemory implements AxAIMemory {
             image: string;
             details?: "high" | "low" | "auto";
             cache?: boolean;
+            optimize?: "quality" | "size" | "auto";
+            altText?: string;
         } | {
             type: "audio";
             data: string;
-            format?: "wav";
+            format?: "wav" | "mp3" | "ogg";
+            cache?: boolean;
+            transcription?: string;
+            duration?: number;
+        } | {
+            type: "file";
+            data: string;
+            filename: string;
+            mimeType: string;
+            cache?: boolean;
+            extractedText?: string;
+        } | {
+            type: "url";
+            url: string;
             cache?: boolean;
+            cachedContent?: string;
+            title?: string;
+            description?: string;
         })[];
     } | {
         role: "assistant";
@@ -3078,7 +3798,7 @@ declare class AxPromptTemplate {
     private readonly functions?;
     constructor(sig: Readonly<AxSignature>, options?: Readonly<AxPromptTemplateOptions>, fieldTemplates?: Record<string, AxFieldTemplateFn>);
     private renderSingleValueUserContent;
-    render: <T extends AxGenIn>(values: T | ReadonlyArray<AxMessage<T>>, // Allow T (AxGenIn) or array of AxMessages
+    render: <T = any>(values: T | ReadonlyArray<AxMessage<T>>, // Allow T or array of AxMessages
     { examples, demos, }: Readonly<{
         skipSystemPrompt?: boolean;
         examples?: Record<string, AxFieldValue>[];
@@ -3096,11 +3816,29 @@ declare class AxPromptTemplate {
         image: string;
         details?: "high" | "low" | "auto";
         cache?: boolean;
+        optimize?: "quality" | "size" | "auto";
+        altText?: string;
     } | {
         type: "audio";
         data: string;
-        format?: "wav";
+        format?: "wav" | "mp3" | "ogg";
         cache?: boolean;
+        transcription?: string;
+        duration?: number;
+    } | {
+        type: "file";
+        data: string;
+        filename: string;
+        mimeType: string;
+        cache?: boolean;
+        extractedText?: string;
+    } | {
+        type: "url";
+        url: string;
+        cache?: boolean;
+        cachedContent?: string;
+        title?: string;
+        description?: string;
     })[];
     private renderExamples;
     private renderDemos;
@@ -3109,6 +3847,165 @@ declare class AxPromptTemplate {
     private defaultRenderInField;
 }
 
+/**
+ * A map of string type names to their corresponding TypeScript types.
+ * Maps signature type strings to actual TypeScript types for type inference.
+ */
+interface TypeMap {
+    string: string;
+    number: number;
+    boolean: boolean;
+    json: any;
+    date: Date;
+    datetime: Date;
+    image: {
+        mimeType: string;
+        data: string;
+    };
+    audio: {
+        format?: 'wav';
+        data: string;
+    };
+    file: {
+        mimeType: string;
+        data: string;
+    };
+    url: string;
+    code: string;
+}
+type ParseClassOptions<S extends string> = S extends `${infer First},${infer Rest}` ? Trim<First> | ParseClassOptions<Trim<Rest>> : S extends `${infer First}|${infer Rest}` ? Trim<First> | ParseClassOptions<Trim<Rest>> : S extends `${infer First} | ${infer Rest}` ? Trim<First> | ParseClassOptions<Trim<Rest>> : S extends `${infer First}, ${infer Rest}` ? Trim<First> | ParseClassOptions<Trim<Rest>> : Trim<S>;
+type ResolveType<T extends string> = T extends keyof TypeMap ? TypeMap[T] : T extends `${infer BaseType}[]` ? BaseType extends keyof TypeMap ? TypeMap[BaseType][] : any[] : T extends `class[]|${infer Options}` ? ParseClassOptions<Options>[] : T extends `class|${infer Options}` ? ParseClassOptions<Options> : T extends 'class' ? string : any;
+type Trim<S extends string> = S extends ` ${infer T}` ? Trim<T> : S extends `\n${infer T}` ? Trim<T> : S extends `\t${infer T}` ? Trim<T> : S extends `\r${infer T}` ? Trim<T> : S extends `${infer U} ` ? Trim<U> : S extends `${infer U}\n` ? Trim<U> : S extends `${infer U}\t` ? Trim<U> : S extends `${infer U}\r` ? Trim<U> : S;
+type ParseField<S extends string> = S extends `${infer Name}?` ? {
+    name: Trim<Name>;
+    optional: true;
+} : {
+    name: Trim<S>;
+    optional: false;
+};
+type ExtractType<S extends string> = S extends `class[] "${infer Options}" "${infer _Desc}"` ? `class[]|${Options}` : S extends `class[] "${infer Options}"` ? `class[]|${Options}` : S extends `class "${infer Options}" "${infer _Desc}"` ? `class|${Options}` : S extends `class "${infer Options}"` ? `class|${Options}` : S extends `${infer Type}[] "${infer _Desc}"` ? `${Type}[]` : S extends `${infer Type}[]` ? `${Type}[]` : S extends `${infer Type} "${infer _Desc}"` ? Type : S;
+type ParseNameAndType<S extends string> = S extends `${infer Name}:${infer TypePart}` ? ParseField<Name> & {
+    type: Trim<ExtractType<Trim<TypePart>>>;
+} : S extends `${infer Name} "${infer _Description}"` ? ParseField<Name> & {
+    type: 'string';
+} : ParseField<S> & {
+    type: 'string';
+};
+/**
+ * Advanced field splitting that respects quotes using a state machine approach.
+ *
+ * This type-level parser solves the core problem of parsing comma-separated fields
+ * when commas can appear both as field separators AND inside quoted strings.
+ *
+ * PROBLEM EXAMPLE:
+ * Input: 'sourceType:class "class1, class2, class3", relevantContext:string, sources:string'
+ *
+ * Simple comma splitting would incorrectly produce:
+ * ['sourceType:class "class1', ' class2', ' class3"', ' relevantContext:string', ' sources:string']
+ *
+ * This parser correctly produces:
+ * ['sourceType:class "class1, class2, class3"', 'relevantContext:string', 'sources:string']
+ *
+ * ALGORITHM:
+ * 1. Process each character in the input string one by one
+ * 2. Track whether we're currently inside or outside quotes
+ * 3. When encountering a quote ("), toggle the quote state
+ * 4. When encountering a comma (,):
+ *    - If inside quotes: treat as literal character, add to current field
+ *    - If outside quotes: treat as field separator, complete current field and start new one
+ * 5. For all other characters: add to current field being built
+ *
+ * STATE PARAMETERS:
+ * @param S - The remaining string to process
+ * @param Current - The current field being built character by character
+ * @param InQuote - Boolean state tracking if we're inside quotes
+ * @param Result - Accumulator array of completed fields
+ */
+type SplitFieldsRespectingQuotes<S extends string, Current extends string = '', InQuote extends boolean = false, Result extends string[] = []> = S extends `${infer Char}${infer Rest}` ? Char extends '"' ? SplitFieldsRespectingQuotes<Rest, `${Current}${Char}`, InQuote extends true ? false : true, Result> : Char extends ',' ? InQuote extends true ? SplitFieldsRespectingQuotes<Rest, `${Current}${Char}`, InQuote, Result> : Rest extends ` ${infer RestTrimmed}` ? SplitFieldsRespectingQuotes<RestTrimmed, '', false, [
+    ...Result,
+    Current
+]> : SplitFieldsRespectingQuotes<Rest, '', false, [...Result, Current]> : SplitFieldsRespectingQuotes<Rest, `${Current}${Char}`, InQuote, Result> : Current extends '' ? Result : [...Result, Current];
+/**
+ * Convert string array to parsed field objects.
+ *
+ * Takes the array of field strings produced by SplitFieldsRespectingQuotes
+ * and converts each string into a structured field object with name, type, and optional properties.
+ *
+ * EXAMPLE:
+ * Input: ['sourceType:class "class1, class2, class3"', 'relevantContext:string', 'sources:string']
+ * Output: [
+ *   { name: 'sourceType', type: 'class|class1, class2, class3', optional: false },
+ *   { name: 'relevantContext', type: 'string', optional: false },
+ *   { name: 'sources', type: 'string', optional: false }
+ * ]
+ */
+type StringArrayToFields<T extends readonly string[]> = T extends readonly [
+    infer First,
+    ...infer Rest
+] ? First extends string ? Rest extends readonly string[] ? [ParseNameAndType<Trim<First>>, ...StringArrayToFields<Rest>] : [ParseNameAndType<Trim<First>>] : [] : [];
+/**
+ * Main field parser using the quote-aware splitter.
+ *
+ * This is the entry point for parsing a field list string into typed field objects.
+ * It combines the quote-aware splitting with field object conversion to produce
+ * the final tuple that BuildObject can use for type inference.
+ *
+ * FLOW:
+ * 1. SplitFieldsRespectingQuotes: 'field1, field2' -> ['field1', 'field2']
+ * 2. StringArrayToFields: ['field1', 'field2'] -> [FieldObj1, FieldObj2]
+ * 3. BuildObject: [FieldObj1, FieldObj2] -> { field1: Type1, field2: Type2 }
+ */
+type ParseFields<S extends string> = StringArrayToFields<SplitFieldsRespectingQuotes<S>>;
+/**
+ * Builds a TypeScript object type from a readonly tuple of field definitions,
+ * supporting both required and optional fields.
+ */
+type BuildObject<T extends readonly {
+    name: string;
+    type: string;
+    optional: boolean;
+}[]> = {
+    -readonly [K in T[number] as K['optional'] extends false ? K['name'] : never]: ResolveType<K['type']>;
+} & {
+    -readonly [K in T[number] as K['optional'] extends true ? K['name'] : never]?: ResolveType<K['type']>;
+};
+type StripSignatureDescription<S extends string> = S extends `"${infer _Desc}" ${infer Rest}` ? Trim<Rest> : S;
+/**
+ * The main signature parser that handles the complete parsing pipeline.
+ *
+ * This is the top-level type that users interact with. It takes a signature string
+ * and produces TypeScript types for both inputs and outputs with proper type inference.
+ *
+ * SIGNATURE FORMAT:
+ * "[description] inputField1:type1, inputField2:type2 -> outputField1:type1, outputField2:type2"
+ *
+ * EXAMPLES:
+ * Simple: 'userQuery:string -> response:string'
+ * Complex: 'searchQuery:string -> sourceType:class "class1, class2, class3", context:string'
+ * With description: '"Analyze text" text:string -> sentiment:class "positive, negative", confidence:number'
+ *
+ * PROCESSING STEPS:
+ * 1. StripSignatureDescription: Remove optional description at start
+ * 2. Split on " -> " to separate inputs from outputs
+ * 3. ParseFields: Use quote-aware parsing for both input and output field lists
+ * 4. BuildObject: Convert field tuples to TypeScript object types
+ *
+ * RESULT TYPE:
+ * {
+ *   inputs: { [fieldName]: FieldType },
+ *   outputs: { [fieldName]: FieldType }
+ * }
+ *
+ * Where FieldType is inferred from the signature (string, number, 'option1'|'option2', etc.)
+ */
+type ParseSignature<S extends string> = StripSignatureDescription<Trim<S>> extends `${infer Inputs} -> ${infer Outputs}` ? {
+    inputs: BuildObject<ParseFields<Trim<Inputs>>>;
+    outputs: BuildObject<ParseFields<Trim<Outputs>>>;
+} : {
+    inputs: Record<string, any>;
+    outputs: Record<string, any>;
+};
+
 type AxFieldValue = string | string[] | number | boolean | object | null | undefined | {
     mimeType: string;
     data: string;
@@ -3128,23 +4025,23 @@ type AxGenIn = {
 type AxGenOut = {
     [key: string]: AxFieldValue;
 };
-type AxMessage<IN extends AxGenIn> = {
+type AxMessage<IN> = {
     role: 'user';
     values: IN;
 } | {
     role: 'assistant';
     values: IN;
 };
-type AxProgramTrace<IN extends AxGenIn, OUT extends AxGenOut> = {
+type AxProgramTrace<IN, OUT> = {
     trace: OUT & IN;
     programId: string;
 };
-type AxProgramDemos<IN extends AxGenIn, OUT extends AxGenOut> = {
+type AxProgramDemos<IN, OUT> = {
     traces: (OUT & IN)[];
     programId: string;
 };
-type AxProgramExamples<IN extends AxGenIn, OUT extends AxGenOut> = AxProgramDemos<IN, OUT> | AxProgramDemos<IN, OUT>['traces'];
-type AxResultPickerFunctionFieldResults<OUT extends AxGenOut> = {
+type AxProgramExamples<IN, OUT> = AxProgramDemos<IN, OUT> | AxProgramDemos<IN, OUT>['traces'];
+type AxResultPickerFunctionFieldResults<OUT> = {
     type: 'fields';
     results: readonly {
         index: number;
@@ -3162,7 +4059,7 @@ type AxResultPickerFunctionFunctionResults = {
         isError?: boolean;
     }[];
 };
-type AxResultPickerFunction<OUT extends AxGenOut> = (data: AxResultPickerFunctionFieldResults<OUT> | AxResultPickerFunctionFunctionResults) => number | Promise<number>;
+type AxResultPickerFunction<OUT> = (data: AxResultPickerFunctionFieldResults<OUT> | AxResultPickerFunctionFunctionResults) => number | Promise<number>;
 type AxProgramForwardOptions<MODEL> = AxAIServiceOptions & {
     maxRetries?: number;
     maxSteps?: number;
@@ -3195,18 +4092,18 @@ type AxProgramStreamingForwardOptions<MODEL> = Omit<AxProgramForwardOptions<MODE
 type AxAIServiceModelType<T extends Readonly<AxAIService<any, any, any>>> = T extends Readonly<AxAIService<infer TModel, any, infer TModelKey>> ? TModel extends unknown ? TModelKey : TModel | TModelKey : never;
 type AxProgramForwardOptionsWithModels<T extends Readonly<AxAIService<any, any, any>>> = AxProgramForwardOptions<AxAIServiceModelType<T>>;
 type AxProgramStreamingForwardOptionsWithModels<T extends Readonly<AxAIService<any, any, any>>> = AxProgramStreamingForwardOptions<AxAIServiceModelType<T>>;
-type AxGenDeltaOut<OUT extends AxGenOut> = {
+type AxGenDeltaOut<OUT> = {
     version: number;
     index: number;
     delta: Partial<OUT>;
 };
-type AxGenStreamingOut<OUT extends AxGenOut> = AsyncGenerator<AxGenDeltaOut<OUT>, void, unknown>;
+type AxGenStreamingOut<OUT> = AsyncGenerator<AxGenDeltaOut<OUT>, void, unknown>;
 type AxSetExamplesOptions = {};
-interface AxForwardable<IN extends AxGenIn, OUT extends AxGenOut, TModelKey> {
+interface AxForwardable<IN, OUT, TModelKey> {
     forward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions<TModelKey>>): Promise<OUT>;
     streamingForward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions<TModelKey>>): AxGenStreamingOut<OUT>;
 }
-interface AxTunable<IN extends AxGenIn, OUT extends AxGenOut> {
+interface AxTunable<IN, OUT> {
     setExamples: (examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>) => void;
     setId: (id: string) => void;
     setParentId: (parentId: string) => void;
@@ -3217,7 +4114,7 @@ interface AxUsable {
     getUsage: () => AxProgramUsage[];
     resetUsage: () => void;
 }
-interface AxProgrammable<IN extends AxGenIn, OUT extends AxGenOut, TModelKey = string> extends AxForwardable<IN, OUT, TModelKey>, AxTunable<IN, OUT>, AxUsable {
+interface AxProgrammable<IN, OUT, TModelKey = string> extends AxForwardable<IN, OUT, TModelKey>, AxTunable<IN, OUT>, AxUsable {
     getSignature: () => AxSignature;
 }
 type AxProgramUsage = AxChatResponse['modelUsage'] & {
@@ -3229,6 +4126,207 @@ interface AxProgramOptions {
     traceLabel?: string;
 }
 
+interface AxFieldType {
+    readonly type: 'string' | 'number' | 'boolean' | 'json' | 'image' | 'audio' | 'file' | 'url' | 'date' | 'datetime' | 'class' | 'code';
+    readonly isArray?: boolean;
+    readonly options?: readonly string[];
+    readonly description?: string;
+    readonly isOptional?: boolean;
+    readonly isInternal?: boolean;
+}
+declare class AxSignatureBuilder<_TInput extends Record<string, any> = {}, _TOutput extends Record<string, any> = {}> {
+    private inputFields;
+    private outputFields;
+    private desc?;
+    /**
+     * Add an input field to the signature
+     * @param name - Field name
+     * @param fieldInfo - Field type created with f.string(), f.number(), etc.
+     * @param prepend - If true, adds field to the beginning of input fields
+     */
+    input<K extends string, T extends AxFluentFieldInfo<any, any, any, any> | AxFluentFieldType>(name: K, fieldInfo: T, prepend?: boolean): AxSignatureBuilder<_TInput & Record<K, InferFluentType<T>>, _TOutput>;
+    /**
+     * Add an output field to the signature
+     * @param name - Field name
+     * @param fieldInfo - Field type created with f.string(), f.number(), etc.
+     * @param prepend - If true, adds field to the beginning of output fields
+     */
+    output<K extends string, T extends AxFluentFieldInfo<any, any, any, any> | AxFluentFieldType>(name: K, fieldInfo: T, prepend?: boolean): AxSignatureBuilder<_TInput, _TOutput & Record<K, InferFluentType<T>>>;
+    /**
+     * Set the description for the signature
+     * @param description - Description text
+     */
+    description(description: string): AxSignatureBuilder<_TInput, _TOutput>;
+    /**
+     * Build the final AxSignature instance
+     */
+    build(): AxSignature<_TInput, _TOutput>;
+}
+declare class AxFluentFieldType implements AxFieldType {
+    readonly type: AxFieldType['type'];
+    readonly isArray?: boolean;
+    readonly options?: readonly string[];
+    readonly description?: string;
+    readonly isOptional?: boolean;
+    readonly isInternal?: boolean;
+    constructor(fieldType: AxFieldType);
+    optional(): AxFluentFieldType;
+    array(): AxFluentFieldType;
+    internal(): AxFluentFieldType;
+}
+declare const f: (() => AxSignatureBuilder) & {
+    string: (desc?: string) => AxFluentFieldType;
+    number: (desc?: string) => AxFluentFieldType;
+    boolean: (desc?: string) => AxFluentFieldType;
+    json: (desc?: string) => AxFluentFieldType;
+    datetime: (desc?: string) => AxFluentFieldType;
+    date: (desc?: string) => AxFluentFieldType;
+    class: <const TOptions extends readonly string[]>(options: TOptions, desc?: string) => AxFluentFieldType;
+    image: (desc?: string) => AxFluentFieldType;
+    audio: (desc?: string) => AxFluentFieldType;
+    file: (desc?: string) => AxFluentFieldType;
+    url: (desc?: string) => AxFluentFieldType;
+    code: (language?: string, desc?: string) => AxFluentFieldType;
+    array: <T extends AxFluentFieldInfo<any, any, any, any>>(baseType: T) => AxFluentFieldInfo<T["type"], true, T["options"], T["isOptional"]>;
+    optional: <T extends AxFluentFieldInfo<any, any, any, any>>(baseType: T) => AxFluentFieldInfo<T["type"], T["isArray"], T["options"], true>;
+    internal: <T extends AxFluentFieldInfo<any, any, any, any>>(baseType: T) => T & {
+        readonly isInternal: true;
+    };
+    legacyArray: <T extends AxFieldType>(baseType: T) => T & {
+        readonly isArray: true;
+    };
+    legacyOptional: <T extends AxFieldType>(baseType: T) => T & {
+        readonly isOptional: true;
+    };
+    legacyInternal: <T extends AxFieldType>(baseType: T) => T & {
+        readonly isInternal: true;
+    };
+};
+interface AxField {
+    name: string;
+    title?: string;
+    description?: string;
+    type?: {
+        name: 'string' | 'number' | 'boolean' | 'json' | 'image' | 'audio' | 'file' | 'url' | 'date' | 'datetime' | 'class' | 'code';
+        isArray?: boolean;
+        options?: string[];
+    };
+    isOptional?: boolean;
+    isInternal?: boolean;
+}
+type AxIField = Omit<AxField, 'title'> & {
+    title: string;
+};
+type InferFieldValueType<T> = T extends AxFieldType | AxFluentFieldType ? T['type'] extends 'string' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'number' ? T['isArray'] extends true ? number[] : number : T['type'] extends 'boolean' ? T['isArray'] extends true ? boolean[] : boolean : T['type'] extends 'json' ? T['isArray'] extends true ? any[] : any : T['type'] extends 'date' ? T['isArray'] extends true ? Date[] : Date : T['type'] extends 'datetime' ? T['isArray'] extends true ? Date[] : Date : T['type'] extends 'image' ? T['isArray'] extends true ? {
+    mimeType: string;
+    data: string;
+}[] : {
+    mimeType: string;
+    data: string;
+} : T['type'] extends 'audio' ? T['isArray'] extends true ? {
+    format?: 'wav';
+    data: string;
+}[] : {
+    format?: 'wav';
+    data: string;
+} : T['type'] extends 'file' ? T['isArray'] extends true ? {
+    mimeType: string;
+    data: string;
+}[] : {
+    mimeType: string;
+    data: string;
+} : T['type'] extends 'url' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'code' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'class' ? T['options'] extends readonly (infer U)[] ? T['isArray'] extends true ? U[] : U : T['isArray'] extends true ? string[] : string : any : any;
+interface AxFluentFieldInfo<TType extends AxFieldType['type'] = AxFieldType['type'], TIsArray extends boolean = false, TOptions extends readonly string[] = readonly string[], TIsOptional extends boolean = false> {
+    readonly type: TType;
+    readonly isArray?: TIsArray;
+    readonly options?: TOptions;
+    readonly description?: string;
+    readonly isOptional?: TIsOptional;
+    readonly isInternal?: boolean;
+}
+type InferFluentType<T extends AxFluentFieldInfo<any, any, any, any> | AxFluentFieldType> = T['type'] extends 'string' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'number' ? T['isArray'] extends true ? number[] : number : T['type'] extends 'boolean' ? T['isArray'] extends true ? boolean[] : boolean : T['type'] extends 'json' ? T['isArray'] extends true ? any[] : any : T['type'] extends 'date' ? T['isArray'] extends true ? Date[] : Date : T['type'] extends 'datetime' ? T['isArray'] extends true ? Date[] : Date : T['type'] extends 'image' ? T['isArray'] extends true ? {
+    mimeType: string;
+    data: string;
+}[] : {
+    mimeType: string;
+    data: string;
+} : T['type'] extends 'audio' ? T['isArray'] extends true ? {
+    format?: 'wav';
+    data: string;
+}[] : {
+    format?: 'wav';
+    data: string;
+} : T['type'] extends 'file' ? T['isArray'] extends true ? {
+    mimeType: string;
+    data: string;
+}[] : {
+    mimeType: string;
+    data: string;
+} : T['type'] extends 'url' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'code' ? T['isArray'] extends true ? string[] : string : T['type'] extends 'class' ? T['options'] extends readonly (infer U)[] ? T['isArray'] extends true ? U[] : U : T['isArray'] extends true ? string[] : string : any;
+interface AxSignatureConfig {
+    description?: string;
+    inputs: readonly AxField[];
+    outputs: readonly AxField[];
+}
+declare class AxSignature<_TInput extends Record<string, any> = Record<string, any>, _TOutput extends Record<string, any> = Record<string, any>> {
+    private description?;
+    private inputFields;
+    private outputFields;
+    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>);
+    /**
+     * 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']>;
+    private parseParsedField;
+    private parseField;
+    setDescription: (desc: string) => void;
+    addInputField: (field: Readonly<AxField>) => void;
+    addOutputField: (field: Readonly<AxField>) => void;
+    setInputFields: (fields: readonly AxField[]) => void;
+    setOutputFields: (fields: readonly AxField[]) => void;
+    getInputFields: () => Readonly<AxIField[]>;
+    getOutputFields: () => Readonly<AxIField[]>;
+    getDescription: () => string | undefined;
+    appendInputField: <K extends string, T extends AxFieldType>(name: K, fieldType: T) => AxSignature<_TInput & Record<K, InferFieldValueType<T>>, _TOutput>;
+    prependInputField: <K extends string, T extends AxFieldType>(name: K, fieldType: T) => AxSignature<Record<K, InferFieldValueType<T>> & _TInput, _TOutput>;
+    appendOutputField: <K extends string, T extends AxFieldType>(name: K, fieldType: T) => AxSignature<_TInput, _TOutput & Record<K, InferFieldValueType<T>>>;
+    prependOutputField: <K extends string, T extends AxFieldType>(name: K, fieldType: T) => AxSignature<_TInput, Record<K, InferFieldValueType<T>> & _TOutput>;
+    private invalidateValidationCache;
+    private toTitle;
+    toJSONSchema: () => AxFunctionJSONSchema;
+    private updateHashLight;
+    private updateHash;
+    private validateSignatureConsistency;
+    validate: () => boolean;
+    hash: () => string;
+    toString: () => string;
+    toJSON: () => {
+        id: string;
+        description: string | undefined;
+        inputFields: AxIField[];
+        outputFields: AxIField[];
+    };
+}
+
 interface AxAssertion {
     fn(values: Record<string, unknown>): Promise<boolean | undefined> | boolean | undefined;
     message?: string;
@@ -3271,7 +4369,7 @@ interface AxFieldProcessor {
     process: AxFieldProcessorProcess | AxStreamingFieldProcessorProcess;
 }
 
-declare class AxProgram<IN extends AxGenIn, OUT extends AxGenOut> implements AxUsable {
+declare class AxProgram<IN, OUT> implements AxUsable {
     protected signature: AxSignature;
     protected sigHash: string;
     protected examples?: OUT[];
@@ -3298,7 +4396,7 @@ declare class AxProgram<IN extends AxGenIn, OUT extends AxGenOut> implements AxU
     setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
 }
 
-type AxGenerateResult<OUT extends AxGenOut> = OUT & {
+type AxGenerateResult<OUT> = OUT & {
     thought?: string;
 };
 interface AxResponseHandlerArgs<T> {
@@ -3322,7 +4420,7 @@ interface AxStreamingEvent<T> {
         functions?: AxChatResponseFunctionCall[];
     };
 }
-declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxProgram<IN, OUT> implements AxProgrammable<IN, OUT> {
+declare class AxGen<IN = any, OUT extends AxGenOut = any> extends AxProgram<IN, OUT> implements AxProgrammable<IN, OUT> {
     private promptTemplate;
     private asserts;
     private streamingAsserts;
@@ -3332,7 +4430,7 @@ declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOu
     private streamingFieldProcessors;
     private excludeContentFromTrace;
     private thoughtFieldName;
-    constructor(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: Readonly<AxProgramForwardOptions<any>>);
+    constructor(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]> | AxSignature<any, any>, options?: Readonly<AxProgramForwardOptions<any>>);
     private getSignatureName;
     private getMetricsInstruments;
     updateMeter(meter?: Meter): void;
@@ -3564,12 +4662,12 @@ type AxOptimizerLoggerData = {
 type AxOptimizerLoggerFunction = (data: AxOptimizerLoggerData) => void;
 
 type AxExample = Record<string, AxFieldValue>;
-type AxMetricFn = <T extends AxGenOut = AxGenOut>(arg0: Readonly<{
+type AxMetricFn = <T = any>(arg0: Readonly<{
     prediction: T;
     example: AxExample;
 }>) => number | Promise<number>;
 type AxMetricFnArgs = Parameters<AxMetricFn>[0];
-type AxMultiMetricFn = <T extends AxGenOut = AxGenOut>(arg0: Readonly<{
+type AxMultiMetricFn = <T = any>(arg0: Readonly<{
     prediction: T;
     example: AxExample;
 }>) => Record<string, number>;
@@ -3625,6 +4723,28 @@ type AxOptimizerArgs = {
     studentAI: AxAIService;
     teacherAI?: AxAIService;
     examples: readonly AxExample[];
+    optimizerEndpoint?: string;
+    optimizerTimeout?: number;
+    optimizerRetries?: number;
+    numCandidates?: number;
+    initTemperature?: number;
+    maxBootstrappedDemos?: number;
+    maxLabeledDemos?: number;
+    numTrials?: number;
+    minibatch?: boolean;
+    minibatchSize?: number;
+    minibatchFullEvalSteps?: number;
+    programAwareProposer?: boolean;
+    dataAwareProposer?: boolean;
+    viewDataBatchSize?: number;
+    tipAwareProposer?: boolean;
+    fewshotAwareProposer?: boolean;
+    earlyStoppingTrials?: number;
+    minImprovementThreshold?: number;
+    bayesianOptimization?: boolean;
+    acquisitionFunction?: 'expected_improvement' | 'upper_confidence_bound' | 'probability_improvement';
+    explorationWeight?: number;
+    sampleCount?: number;
     validationSet?: readonly AxExample[];
     minSuccessRate?: number;
     targetScore?: number;
@@ -3717,17 +4837,17 @@ interface AxOptimizerMetricsInstruments {
 }
 declare const axUpdateOptimizerMetricsConfig: (config: Readonly<Partial<AxOptimizerMetricsConfig>>) => void;
 declare const axGetOptimizerMetricsConfig: () => AxOptimizerMetricsConfig;
-interface AxOptimizerResult<OUT extends AxGenOut> {
-    demos?: AxProgramDemos<AxGenIn, OUT>[];
+interface AxOptimizerResult<OUT> {
+    demos?: AxProgramDemos<any, OUT>[];
     stats: AxOptimizationStats;
     bestScore: number;
     finalConfiguration?: Record<string, unknown>;
     scoreHistory?: number[];
     configurationHistory?: Record<string, unknown>[];
 }
-interface AxParetoResult<OUT extends AxGenOut = AxGenOut> extends AxOptimizerResult<OUT> {
+interface AxParetoResult<OUT = any> extends AxOptimizerResult<OUT> {
     paretoFront: ReadonlyArray<{
-        demos: readonly AxProgramDemos<AxGenIn, OUT>[];
+        demos: readonly AxProgramDemos<any, OUT>[];
         scores: Readonly<Record<string, number>>;
         configuration: Readonly<Record<string, unknown>>;
         dominatedSolutions: number;
@@ -3751,7 +4871,7 @@ interface AxCompileOptions {
     overrideCheckpointInterval?: number;
     saveCheckpointOnComplete?: boolean;
 }
-interface AxOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> {
+interface AxOptimizer<IN = any, OUT extends AxGenOut = any> {
     /**
      * Optimize a program using the provided metric function
      * @param program The program to optimize (moved from constructor)
@@ -3852,11 +4972,11 @@ interface AxMiPROOptimizerOptions {
 interface AxBootstrapCompileOptions extends AxCompileOptions {
     validationExamples?: readonly AxExample[];
     maxDemos?: number;
-    teacherProgram?: Readonly<AxGen<AxGenIn, AxGenOut>>;
+    teacherProgram?: Readonly<AxGen<any, any>>;
 }
 interface AxMiPROCompileOptions extends AxCompileOptions {
     validationExamples?: readonly AxExample[];
-    teacher?: Readonly<AxGen<AxGenIn, AxGenOut>>;
+    teacher?: Readonly<AxGen<any, any>>;
     auto?: 'light' | 'medium' | 'heavy';
     instructionCandidates?: string[];
     customProposer?: (context: Readonly<{
@@ -3883,7 +5003,7 @@ declare class AxDefaultCostTracker implements AxCostTracker {
  * Abstract base class for optimizers that provides common functionality
  * and standardized handling of AxOptimizerArgs
  */
-declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> implements AxOptimizer<IN, OUT> {
+declare abstract class AxBaseOptimizer<IN = any, OUT extends AxGenOut = any> implements AxOptimizer<IN, OUT> {
     protected readonly studentAI: AxAIService;
     protected readonly teacherAI?: AxAIService;
     protected readonly examples: readonly AxExample[];
@@ -4206,7 +5326,7 @@ declare const axCreateDefaultOptimizerTextLogger: (output?: (message: string) =>
  */
 declare const axDefaultOptimizerLogger: AxOptimizerLoggerFunction;
 
-declare class AxBootstrapFewShot<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
+declare class AxBootstrapFewShot<IN = any, OUT extends AxGenOut = any> extends AxBaseOptimizer<IN, OUT> {
     private maxRounds;
     private maxDemos;
     private maxExamples;
@@ -4249,9 +5369,8 @@ declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
     private sampleCount;
     private miproConfigHistory;
     private surrogateModel;
-    constructor(args: Readonly<AxOptimizerArgs & {
-        options?: AxMiPROOptimizerOptions;
-    }>);
+    private pythonClient?;
+    constructor(args: Readonly<AxOptimizerArgs>);
     /**
      * Configures the optimizer for light, medium, or heavy optimization
      * @param level The optimization level: "light", "medium", or "heavy"
@@ -4333,6 +5452,10 @@ declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * Encodes a configuration into a string key for surrogate model lookup
      */
     private encodeConfiguration;
+    /**
+     * Simple string hash function for instruction content
+     */
+    private hashString;
     /**
      * Updates the surrogate model with a new configuration-score pair
      */
@@ -4353,17 +5476,29 @@ declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGen
      * Selects the next configuration to evaluate using Bayesian optimization
      */
     private selectConfigurationViaBayesianOptimization;
+    /**
+     * Python-based compilation method
+     *
+     * This is a simplified implementation that demonstrates integration
+     * with the Python optimizer service. For now, it focuses on basic
+     * parameter optimization rather than full MiPRO functionality.
+     */
+    private compilePython;
+    /**
+     * Simplified evaluation method for Python optimization
+     */
+    private evaluateConfiguration;
 }
 
-type AxInstanceRegistryItem<T extends AxTunable<IN, OUT>, IN extends AxGenIn, OUT extends AxGenOut> = T & AxUsable;
-declare class AxInstanceRegistry<T extends AxTunable<IN, OUT>, IN extends AxGenIn, OUT extends AxGenOut> {
+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 extends AxGenOut> {
+interface AxSamplePickerOptions<OUT> {
     resultPicker?: AxResultPickerFunction<OUT>;
 }
 
@@ -4379,45 +5514,8 @@ declare const AxStringUtil: {
     batchArray: <T>(arr: readonly T[], size: number) => T[][];
 };
 
-type AxSignatureTemplateValue = string | AxFieldType | AxFieldDescriptor | AxSignature;
-interface AxFieldType {
-    readonly type: 'string' | 'number' | 'boolean' | 'json' | 'image' | 'audio' | 'date' | 'datetime' | 'class' | 'code';
-    readonly isArray?: boolean;
-    readonly options?: readonly string[];
-    readonly description?: string;
-    readonly isOptional?: boolean;
-    readonly isInternal?: boolean;
-}
-interface AxFieldDescriptor {
-    readonly name: string;
-    readonly type?: AxFieldType;
-    readonly description?: string;
-    readonly isOptional?: boolean;
-    readonly isInternal?: boolean;
-}
-declare function s(strings: TemplateStringsArray, ...values: readonly AxSignatureTemplateValue[]): AxSignature;
-declare function ax<IN extends AxGenIn = AxGenIn, OUT extends AxGenerateResult<AxGenOut> = AxGenerateResult<AxGenOut>>(strings: TemplateStringsArray, ...values: readonly AxSignatureTemplateValue[]): AxGen<IN, OUT>;
-declare const f: {
-    string: (desc?: string) => AxFieldType;
-    number: (desc?: string) => AxFieldType;
-    boolean: (desc?: string) => AxFieldType;
-    date: (desc?: string) => AxFieldType;
-    datetime: (desc?: string) => AxFieldType;
-    json: (desc?: string) => AxFieldType;
-    image: (desc?: string) => AxFieldType;
-    audio: (desc?: string) => AxFieldType;
-    class: (options: readonly string[], desc?: string) => AxFieldType;
-    code: (language: string, desc?: string) => AxFieldType;
-    array: <T extends AxFieldType>(baseType: T) => T & {
-        readonly isArray: true;
-    };
-    optional: <T extends AxFieldType>(baseType: T) => T & {
-        readonly isOptional: true;
-    };
-    internal: <T extends AxFieldType>(baseType: T) => T & {
-        readonly isInternal: true;
-    };
-};
+declare function s<const T extends string>(signature: T): AxSignature<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>;
+declare function ax<const T extends string>(signature: T, options?: Readonly<AxProgramForwardOptions<any>>): AxGen<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>;
 
 /**
  * Analyzes mapping functions to extract state dependencies.
@@ -4518,18 +5616,18 @@ interface AxFlowDynamicContext<T extends Readonly<AxAIService>> {
     ai?: T;
     options?: AxProgramForwardOptions<NonNullable<ReturnType<T['getModelList']>>[number]['key']>;
 }
-type GetGenIn<T extends AxProgrammable<AxGenIn, AxGenOut>> = T extends AxProgrammable<infer IN, AxGenOut> ? IN : never;
-type GetGenOut<T extends AxProgrammable<AxGenIn, AxGenOut>> = T extends AxProgrammable<AxGenIn, infer OUT> ? OUT : never;
-type InferAxGen<TSig extends string> = TSig extends string ? AxGen<AxGenIn, AxGenOut> : never;
+type GetGenIn<T extends AxProgrammable<any, any>> = T extends AxProgrammable<infer IN, any> ? IN : never;
+type GetGenOut<T extends AxProgrammable<any, any>> = T extends AxProgrammable<any, infer OUT> ? OUT : never;
+type InferAxGen<TSig extends string> = AxGen<ParseSignature<TSig>['inputs'], ParseSignature<TSig>['outputs']>;
 type NodeResultKey<TNodeName extends string> = `${TNodeName}Result`;
-type AddNodeResult<TState extends AxFlowState, TNodeName extends string, TNodeOut extends AxGenOut> = TState & {
+type AddNodeResult<TState extends AxFlowState, TNodeName extends string, TNodeOut> = TState & {
     [K in NodeResultKey<TNodeName>]: TNodeOut;
 };
 /**
  * Interface for flows that can be tuned, executed, and used in compositions.
  * Provides methods for building and executing complex AI workflows.
  */
-interface AxFlowable<IN extends AxGenIn, OUT extends AxGenOut> extends AxProgrammable<IN, OUT> {
+interface AxFlowable<IN, OUT> extends AxProgrammable<IN, OUT> {
 }
 type AxFlowTypedParallelBranch<TNodes extends Record<string, AxProgrammable<any, any>>, TState extends AxFlowState> = (subFlow: AxFlowTypedSubContext<TNodes, TState>) => AxFlowTypedSubContext<TNodes, AxFlowState>;
 interface AxFlowTypedSubContext<TNodes extends Record<string, AxProgrammable<any, any>>, TState extends AxFlowState> {
@@ -4791,6 +5889,92 @@ declare class AxFlowExecutionPlanner {
     };
 }
 
+/**
+ * Data types for different AxFlow logging events
+ */
+interface AxFlowLoggerData {
+    name: string;
+    timestamp: number;
+    [key: string]: unknown;
+}
+interface AxFlowStartData extends AxFlowLoggerData {
+    name: 'FlowStart';
+    inputFields: string[];
+    totalSteps: number;
+    parallelGroups: number;
+    maxParallelism: number;
+    autoParallelEnabled: boolean;
+}
+interface AxFlowStepStartData extends AxFlowLoggerData {
+    name: 'StepStart';
+    stepIndex: number;
+    stepType: 'execute' | 'map' | 'merge' | 'parallel-map' | 'parallel' | 'derive' | 'branch' | 'feedback' | 'while' | 'other';
+    nodeName?: string;
+    dependencies: string[];
+    produces: string[];
+    state: AxFlowState;
+}
+interface AxFlowStepCompleteData extends AxFlowLoggerData {
+    name: 'StepComplete';
+    stepIndex: number;
+    stepType: 'execute' | 'map' | 'merge' | 'parallel-map' | 'parallel' | 'derive' | 'branch' | 'feedback' | 'while' | 'other';
+    nodeName?: string;
+    executionTime: number;
+    state: AxFlowState;
+    newFields?: string[];
+    result?: any;
+}
+interface AxFlowParallelGroupStartData extends AxFlowLoggerData {
+    name: 'ParallelGroupStart';
+    groupLevel: number;
+    stepsCount: number;
+    stepTypes: string[];
+}
+interface AxFlowParallelGroupCompleteData extends AxFlowLoggerData {
+    name: 'ParallelGroupComplete';
+    groupLevel: number;
+    stepsCount: number;
+    executionTime: number;
+}
+interface AxFlowBranchEvaluationData extends AxFlowLoggerData {
+    name: 'BranchEvaluation';
+    branchValue: unknown;
+    hasMatchingBranch: boolean;
+    branchStepsCount: number;
+}
+interface AxFlowCompleteData extends AxFlowLoggerData {
+    name: 'FlowComplete';
+    totalExecutionTime: number;
+    finalState: AxFlowState;
+    outputFields: string[];
+    stepsExecuted: number;
+}
+interface AxFlowErrorData extends AxFlowLoggerData {
+    name: 'FlowError';
+    error: string;
+    stepIndex?: number;
+    stepType?: string;
+    nodeName?: string;
+    state?: AxFlowState;
+}
+type AxFlowLogData = AxFlowStartData | AxFlowStepStartData | AxFlowStepCompleteData | AxFlowParallelGroupStartData | AxFlowParallelGroupCompleteData | AxFlowBranchEvaluationData | AxFlowCompleteData | AxFlowErrorData;
+/**
+ * Function type for AxFlow logging
+ */
+type AxFlowLoggerFunction = (data: AxFlowLogData) => void;
+/**
+ * Factory function to create a colorized AxFlow logger
+ */
+declare const axCreateFlowColorLogger: (output?: (message: string) => void) => AxFlowLoggerFunction;
+/**
+ * Factory function to create a text-only AxFlow logger (no colors)
+ */
+declare const axCreateFlowTextLogger: (output?: (message: string) => void) => AxFlowLoggerFunction;
+/**
+ * Default AxFlow logger with colors
+ */
+declare const axDefaultFlowLogger: AxFlowLoggerFunction;
+
 /**
  * AxFlow - A fluent, chainable API for building and orchestrating complex, stateful AI programs.
  *
@@ -4809,7 +5993,7 @@ declare class AxFlowExecutionPlanner {
  * const result = await flow.forward(ai, { topic: "AI safety" })
  * ```
  */
-declare class AxFlow<IN extends AxGenIn, OUT extends AxGenOut, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, // Node registry for type tracking
+declare class AxFlow<IN extends Record<string, any>, OUT, TNodes extends Record<string, AxProgrammable<any, any>> = Record<string, never>, // Node registry for type tracking
 TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     private readonly nodes;
     private readonly flowDefinition;
@@ -4822,10 +6006,28 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     private program?;
     private nodeUsage;
     private nodeTraces;
+    private readonly flowLogger?;
+    private readonly timingLogger?;
     /**
      * Converts a string to camelCase for valid field names
      */
     private toCamelCase;
+    /**
+     * 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
@@ -4849,7 +6051,20 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     constructor(options?: {
         autoParallel?: boolean;
         batchSize?: number;
+        logger?: AxFlowLoggerFunction;
+        debug?: boolean;
     });
+    /**
+     * 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
      */
@@ -4942,7 +6157,7 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
      *
      * @example
      * ```
-     * const sig = new AxSignature('text:string -> summary:string')
+     * const sig = s('text:string -> summary:string')
      * flow.node('summarizer', sig, { temperature: 0.1 })
      * ```
      */
@@ -5010,6 +6225,22 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
      * ```
      */
     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.
@@ -5032,16 +6263,65 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
     map<TNewState extends AxFlowState>(transforms: Array<(_state: TState) => TNewState>, options: {
         parallel: true;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
-    map<TNewState extends AxFlowState>(transform: (_state: TState) => TNewState, options?: {
+    /**
+     * 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
+     * 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: {
         parallel: true;
     }): AxFlow<IN, OUT, TNodes, TNewState>;
+    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).
      *
@@ -5280,7 +6560,146 @@ TState extends AxFlowState = IN> implements AxFlowable<IN, OUT> {
         groups?: AxFlowParallelGroup[];
     };
     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.internal(f.string('Step-by-step reasoning')) }
+     *   ]
+     * })
+     *
+     * // Create a node with context and confidence
+     * flow.nodeExtended('analyzer', 'input:string -> output:string', {
+     *   appendInputs: [{ name: 'context', type: f.optional(f.string('Context')) }],
+     *   appendOutputs: [{ name: 'confidence', type: f.number('Confidence score') }]
+     * })
+     * ```
+     */
+    nodeExtended<TName extends string>(name: TName, baseSignature: string | AxSignature, extensions: {
+        prependInputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+        appendInputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+        prependOutputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+        appendOutputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+    }): 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;
+            type: AxFieldType;
+        }>;
+        appendInputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+        prependOutputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+        appendOutputs?: Array<{
+            name: string;
+            type: AxFieldType;
+        }>;
+    }): 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
@@ -5662,6 +7081,29 @@ interface AxAgentFeatures {
 /**
  * An AI agent that can process inputs using an AI service and coordinate with child agents.
  * Supports features like smart model routing and automatic input field passing to child agents.
+ *
+ * @deprecated Use the `agent()` factory function instead of instantiating this class directly.
+ * The factory function provides better type inference and cleaner syntax.
+ * This class 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
+ * // Old (deprecated):
+ * const myAgent = new AxAgent({
+ *   name: 'myAgent',
+ *   description: 'An agent that does something',
+ *   signature: 'userInput:string -> responseText:string'
+ * });
+ *
+ * // New (recommended):
+ * const myAgent = agent('userInput:string -> responseText:string', {
+ *   name: 'myAgent',
+ *   description: 'An agent that does something'
+ * });
  */
 declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAgentic<IN, OUT> {
     private ai?;
@@ -5682,6 +7124,28 @@ declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAge
         agents?: AxAgentic<IN, OUT>[];
         functions?: AxInputFunctionType;
     }>, options?: Readonly<AxAgentOptions>);
+    /**
+     * Creates a new AxAgent instance with type-safe signature parsing.
+     * This is the recommended way to create agents with string-based signatures.
+     *
+     * @param signature - The signature string defining input/output fields
+     * @param config - Agent configuration including name, description, etc.
+     * @returns A new AxAgent instance with inferred types
+     *
+     * @example
+     * ```typescript
+     * const agent = AxAgent.create(
+     *   'userInput:string "User question" -> responseText:string "Agent response"',
+     *   {
+     *     name: 'helpfulAgent',
+     *     description: 'An agent that provides helpful responses to user questions',
+     *     definition: 'You are a helpful assistant that provides clear, accurate responses to user questions.',
+     *     ai: llm
+     *   }
+     * );
+     * ```
+     */
+    static create<const T extends string>(signature: T, config: AxAgentConfig<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>): AxAgent<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>;
     setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
     setId(id: string): void;
     setParentId(parentId: string): void;
@@ -5713,35 +7177,220 @@ declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAge
     setSignature(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>): void;
     private getDebug;
 }
-
-declare class AxChainOfThought<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxGen<IN, OUT> {
-    constructor(signature: Readonly<AxSignature | string>, options?: Readonly<AxProgramForwardOptions<string> & {
-        setVisibleReasoning?: boolean;
-    }>);
+/**
+ * Configuration options for creating an agent using the agent() factory function.
+ */
+interface AxAgentConfig<IN extends AxGenIn, OUT extends AxGenOut> extends AxAgentOptions {
+    ai?: AxAIService;
+    name: string;
+    description: string;
+    definition?: string;
+    agents?: AxAgentic<IN, OUT>[];
+    functions?: AxInputFunctionType;
 }
+/**
+ * Creates a strongly-typed AI agent from a string signature.
+ * This is the recommended way to create agents, providing better type inference and cleaner syntax.
+ *
+ * @param signature - The input/output signature as a string (e.g., "userInput:string -> responseText:string")
+ * @param config - Configuration options for the agent
+ * @returns A typed agent instance
+ *
+ * @example
+ * ```typescript
+ * const myAgent = agent('userInput:string -> responseText:string', {
+ *   name: 'myAgent',
+ *   description: 'An agent that processes user input and returns a response',
+ *   definition: 'You are a helpful assistant that responds to user queries...'
+ * });
+ *
+ * // With child agents
+ * const parentAgent = agent('taskDescription:string -> completedTask:string', {
+ *   name: 'parentAgent',
+ *   description: 'Coordinates child agents to complete tasks',
+ *   agents: [childAgent1, childAgent2]
+ * });
+ *
+ * // Type-safe usage
+ * const result = await myAgent.forward(ai, { userInput: 'Hello!' });
+ * console.log(result.responseText); // TypeScript knows this exists
+ * ```
+ */
+declare function agent<const T extends string>(signature: T, config: AxAgentConfig<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>): AxAgent<ParseSignature<T>['inputs'], ParseSignature<T>['outputs']>;
 
-declare class AxRAG extends AxChainOfThought<{
-    context: string[];
-    question: string;
+/**
+ * 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;
 }, {
-    answer: string;
-}> {
-    private genQuery;
-    private queryFn;
-    private maxHops;
-    constructor(queryFn: (query: string) => Promise<string>, options: Readonly<AxProgramForwardOptions<string> & {
-        maxHops?: number;
-    }>);
-    forward<T extends Readonly<AxAIService>>(ai: T, values: {
-        context: string[];
-        question: string;
-    } | AxMessage<{
-        context: string[];
-        question: string;
-    }>[], options?: Readonly<AxProgramForwardOptionsWithModels<T>>): Promise<{
-        answer: 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;
+    } & {
+        type: "string";
+    }, {
+        name: "queryReasoning";
+        optional: false;
+    } & {
+        type: "string";
+    }]>;
+    contextualizerResult: BuildObject<[{
+        name: "enhancedContext";
+        optional: false;
+    } & {
+        type: "string";
+    }]>;
+    qualityAssessorResult: BuildObject<[{
+        name: "completenessScore";
+        optional: false;
+    } & {
+        type: "number";
+    }, {
+        name: "missingAspects";
+        optional: false;
+    } & {
+        type: "string[]";
+    }]>;
+    queryRefinerResult: BuildObject<[{
+        name: "refinedQuery";
+        optional: false;
+    } & {
+        type: "string";
+    }]>;
+    questionDecomposerResult: BuildObject<[{
+        name: "subQuestions";
+        optional: false;
+    } & {
+        type: "string[]";
+    }, {
+        name: "decompositionReason";
+        optional: false;
+    } & {
+        type: "string";
+    }]>;
+    evidenceSynthesizerResult: BuildObject<[{
+        name: "synthesizedEvidence";
+        optional: false;
+    } & {
+        type: "string";
+    }, {
+        name: "evidenceGaps";
+        optional: false;
+    } & {
+        type: "string[]";
+    }]>;
+    gapAnalyzerResult: BuildObject<[{
+        name: "needsMoreInfo";
+        optional: false;
+    } & {
+        type: "boolean";
+    }, {
+        name: "focusedQueries";
+        optional: false;
+    } & {
+        type: "string[]";
+    }]>;
+    answerGeneratorResult: BuildObject<[{
+        name: "comprehensiveAnswer";
+        optional: false;
+    } & {
+        type: "string";
+    }, {
+        name: "confidenceLevel";
+        optional: false;
+    } & {
+        type: "number";
+    }]>;
+    qualityValidatorResult: BuildObject<[{
+        name: "qualityScore";
+        optional: false;
+    } & {
+        type: "number";
+    }, {
+        name: "issues";
+        optional: false;
+    } & {
+        type: "string[]";
+    }]>;
+    answerHealerResult: BuildObject<[{
+        name: "healedAnswer";
+        optional: false;
+    } & {
+        type: "string";
+    }]>;
+}>;
 
 declare const axSpanAttributes: {
     LLM_SYSTEM: string;
@@ -5814,4 +7463,4 @@ declare class AxRateLimiterTokenUsage {
     acquire(tokens: number): Promise<void>;
 }
 
-export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, 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, AxAIWebLLM, type AxAIWebLLMArgs, type AxAIWebLLMChatRequest, type AxAIWebLLMChatResponse, type AxAIWebLLMChatResponseDelta, type AxAIWebLLMConfig, type AxAIWebLLMEmbedModel, type AxAIWebLLMEmbedRequest, type AxAIWebLLMEmbedResponse, AxAIWebLLMModel, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, AxChainOfThought, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type AxFieldDescriptor, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, type AxFlowAutoParallelConfig, type AxFlowBranchContext, AxFlowDependencyAnalyzer, type AxFlowDynamicContext, AxFlowExecutionPlanner, type AxFlowExecutionStep, type AxFlowNodeDefinition, type AxFlowParallelBranch, type AxFlowParallelGroup, type AxFlowState, type AxFlowStepFunction, type AxFlowSubContext, AxFlowSubContextImpl, type AxFlowTypedParallelBranch, type AxFlowTypedSubContext, AxFlowTypedSubContextImpl, type AxFlowable, type AxForwardable, type AxFunction, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, type AxFunctionResultFormatter, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenMetricsInstruments, type AxGenOut, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, AxLLMRequestTypeValues, type AxLoggerData, type AxLoggerFunction, AxMCPClient, type AxMCPFunctionDescription, AxMCPHTTPSSETransport, type AxMCPInitializeParams, type AxMCPInitializeResult, type AxMCPJSONRPCErrorResponse, type AxMCPJSONRPCNotification, type AxMCPJSONRPCRequest, type AxMCPJSONRPCResponse, type AxMCPJSONRPCSuccessResponse, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPToolsListResult, type AxMCPTransport, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerLoggerData, type AxOptimizerLoggerFunction, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramForwardOptionsWithModels, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramStreamingForwardOptionsWithModels, type AxProgramTrace, type AxProgramUsage, type AxProgrammable, AxPromptTemplate, type AxPromptTemplateOptions, AxRAG, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, type AxSignatureConfig, type AxSignatureTemplateValue, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axAIWebLLMCreativeConfig, axAIWebLLMDefaultConfig, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultColorLogger, axCreateDefaultOptimizerColorLogger, axCreateDefaultOptimizerTextLogger, axCreateDefaultTextLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axModelInfoWebLLM, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, f, s };
+export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, 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, AxAIWebLLM, type AxAIWebLLMArgs, type AxAIWebLLMChatRequest, type AxAIWebLLMChatResponse, type AxAIWebLLMChatResponseDelta, type AxAIWebLLMConfig, type AxAIWebLLMEmbedModel, type AxAIWebLLMEmbedRequest, type AxAIWebLLMEmbedResponse, AxAIWebLLMModel, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentConfig, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, AxContentProcessingError, type AxContentProcessingServices, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type 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, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, type AxFunctionResultFormatter, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenMetricsInstruments, type AxGenOut, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, AxLLMRequestTypeValues, type AxLoggerData, type AxLoggerFunction, AxMCPClient, type AxMCPFunctionDescription, AxMCPHTTPSSETransport, type AxMCPInitializeParams, type AxMCPInitializeResult, type AxMCPJSONRPCErrorResponse, type AxMCPJSONRPCNotification, type AxMCPJSONRPCRequest, type AxMCPJSONRPCResponse, type AxMCPJSONRPCSuccessResponse, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPToolsListResult, type AxMCPTransport, AxMediaNotSupportedError, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, type AxMultiProviderConfig, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerLoggerData, type AxOptimizerLoggerFunction, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramForwardOptionsWithModels, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramStreamingForwardOptionsWithModels, type AxProgramTrace, type AxProgramUsage, type AxProgrammable, AxPromptTemplate, type AxPromptTemplateOptions, AxProviderRouter, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxRoutingResult, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, AxSignatureBuilder, type AxSignatureConfig, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, agent, ai, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axAIWebLLMCreativeConfig, axAIWebLLMDefaultConfig, axAnalyzeChatPromptRequirements, axAnalyzeRequestRequirements, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultColorLogger, axCreateDefaultOptimizerColorLogger, axCreateDefaultOptimizerTextLogger, axCreateDefaultTextLogger, axCreateFlowColorLogger, axCreateFlowTextLogger, axDefaultFlowLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetCompatibilityReport, axGetFormatCompatibility, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGetProvidersWithMediaSupport, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axModelInfoWebLLM, axProcessContentForProvider, axRAG, axScoreProvidersForRequest, axSelectOptimalProvider, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, axValidateProviderCapabilities, f, flow, s };