@ax-llm/ax 12.0.25 → 13.0.2

package/index.d.cts

@@ -1,6 +1,4 @@
-import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
 import { Span, Context, Tracer, Meter, Histogram, Counter, Gauge } from '@opentelemetry/api';
-import { ReadableStream } from 'stream/web';
 
 interface RetryConfig {
     maxRetries: number;
@@ -75,98 +73,6 @@ declare class AxAIRefusalError extends Error {
     toString(): string;
 }
 
-interface AxAIFeatures {
-    functions: boolean;
-    streaming: boolean;
-    functionCot?: boolean;
-    hasThinkingBudget?: boolean;
-    hasShowThoughts?: boolean;
-}
-interface AxBaseAIArgs<TModel, TEmbedModel> {
-    name: string;
-    apiURL: string;
-    headers: () => Promise<Record<string, string>>;
-    modelInfo: Readonly<AxModelInfo[]>;
-    defaults: Readonly<{
-        model: TModel;
-        embedModel?: TEmbedModel;
-    }>;
-    options?: Readonly<AxAIServiceOptions>;
-    supportFor: AxAIFeatures | ((model: TModel) => AxAIFeatures);
-    models?: AxAIInputModelList<TModel, TEmbedModel>;
-}
-declare const axBaseAIDefaultConfig: () => AxModelConfig;
-declare const axBaseAIDefaultCreativeConfig: () => AxModelConfig;
-declare class AxBaseAI<TModel, TEmbedModel, TChatRequest, TEmbedRequest, TChatResponse, TChatResponseDelta, TEmbedResponse> implements AxAIService<TModel, TEmbedModel> {
-    private readonly aiImpl;
-    private debug;
-    private rt?;
-    private fetch?;
-    private tracer?;
-    private meter?;
-    private timeout?;
-    private excludeContentFromTrace?;
-    private models?;
-    private abortSignal?;
-    private logger;
-    private modelInfo;
-    private modelUsage?;
-    private embedModelUsage?;
-    private defaults;
-    private lastUsedModelConfig?;
-    private lastUsedChatModel?;
-    private lastUsedEmbedModel?;
-    protected apiURL: string;
-    protected name: string;
-    protected id: string;
-    protected headers: () => Promise<Record<string, string>>;
-    protected supportFor: AxAIFeatures | ((model: TModel) => AxAIFeatures);
-    private metrics;
-    constructor(aiImpl: Readonly<AxAIServiceImpl<TModel, TEmbedModel, TChatRequest, TEmbedRequest, TChatResponse, TChatResponseDelta, TEmbedResponse>>, { name, apiURL, headers, modelInfo, defaults, options, supportFor, models, }: Readonly<AxBaseAIArgs<TModel, TEmbedModel>>);
-    private getMetricsInstruments;
-    setName(name: string): void;
-    getId(): string;
-    setAPIURL(apiURL: string): void;
-    setHeaders(headers: () => Promise<Record<string, string>>): void;
-    setOptions(options: Readonly<AxAIServiceOptions>): void;
-    getOptions(): Readonly<AxAIServiceOptions>;
-    getLogger(): AxLoggerFunction;
-    getModelList(): AxAIModelList | undefined;
-    getName(): string;
-    getFeatures(model?: TModel): AxAIFeatures;
-    getLastUsedChatModel(): TModel | undefined;
-    getLastUsedEmbedModel(): TEmbedModel | undefined;
-    getLastUsedModelConfig(): AxModelConfig | undefined;
-    private calculatePercentile;
-    private updateLatencyMetrics;
-    private updateErrorMetrics;
-    private recordTokenUsage;
-    private calculateRequestSize;
-    private calculateResponseSize;
-    private detectMultimodalContent;
-    private calculatePromptLength;
-    private calculateContextWindowUsage;
-    private estimateCost;
-    private estimateCostByName;
-    private recordFunctionCallMetrics;
-    private recordTimeoutMetric;
-    private recordAbortMetric;
-    private recordChatMetrics;
-    private recordEmbedMetrics;
-    getMetrics(): AxAIServiceMetrics;
-    chat(req: Readonly<AxChatRequest<TModel>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
-    private _chat1;
-    private cleanupFunctionSchema;
-    private _chat2;
-    embed(req: Readonly<AxEmbedRequest<TEmbedModel>>, options?: Readonly<AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxEmbedResponse>;
-    private _embed1;
-    private _embed2;
-    private buildHeaders;
-    private getModelByKey;
-    private getModel;
-    private getEmbedModel;
-}
-
 type AxAIInputModelList<TModel, TEmbedModel> = (AxAIModelListBase & {
     isInternal?: boolean;
 } & ({
@@ -376,10 +282,10 @@ type AxEmbedRequest<TEmbedModel = string> = {
     embedModel?: TEmbedModel;
 };
 type AxInternalEmbedRequest<TEmbedModel> = Omit<AxEmbedRequest, 'embedModel'> & Required<Pick<AxEmbedRequest<TEmbedModel>, 'embedModel'>>;
-type AxRateLimiterFunction = <T = unknown>(reqFunc: () => Promise<T | ReadableStream$1<T>>, info: Readonly<{
+type AxRateLimiterFunction = <T = unknown>(reqFunc: () => Promise<T | ReadableStream<T>>, info: Readonly<{
     modelUsage?: AxModelUsage;
-}>) => Promise<T | ReadableStream$1<T>>;
-type AxLoggerTag = 'error' | 'warning' | 'success' | 'functionName' | 'functionArg' | 'functionEnd' | 'functionResult' | 'functionError' | 'firstFunction' | 'multipleFunctions' | 'responseStart' | 'responseContent' | 'responseDelta' | 'responseEnd' | 'requestStart' | 'requestContent' | 'requestEnd' | 'systemStart' | 'systemContent' | 'systemEnd' | 'userStart' | 'userContent' | 'userEnd' | 'assistantStart' | 'assistantContent' | 'assistantEnd' | 'discovery' | 'optimizer' | 'start' | 'config' | 'phase' | 'progress' | 'result' | 'complete' | 'checkpoint';
+}>) => Promise<T | ReadableStream<T>>;
+type AxLoggerTag = 'error' | 'warning' | 'functionName' | 'functionArg' | 'functionEnd' | 'functionResult' | 'functionError' | 'firstFunction' | 'multipleFunctions' | 'responseContent' | 'responseDelta' | 'responseEnd' | 'requestStart' | 'requestContent' | 'systemContent' | 'userStart' | 'userContent' | 'assistantStart' | 'assistantContent' | 'assistantEnd' | 'discovery' | 'optimizer' | 'start' | 'end' | 'config' | 'phase' | 'progress' | 'result' | 'complete' | 'checkpoint';
 type AxLoggerFunction = (message: string, options?: {
     tags?: AxLoggerTag[];
 }) => void;
@@ -422,21 +328,113 @@ interface AxAIService<TModel = unknown, TEmbedModel = unknown> {
     getLastUsedChatModel(): TModel | undefined;
     getLastUsedEmbedModel(): TEmbedModel | undefined;
     getLastUsedModelConfig(): AxModelConfig | undefined;
-    chat(req: Readonly<AxChatRequest<TModel>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxChatResponse | ReadableStream$1<AxChatResponse>>;
+    chat(req: Readonly<AxChatRequest<TModel>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
     embed(req: Readonly<AxEmbedRequest<TEmbedModel>>, options?: Readonly<AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxEmbedResponse>;
     setOptions(options: Readonly<AxAIServiceOptions>): void;
     getOptions(): Readonly<AxAIServiceOptions>;
 }
 interface AxAIServiceImpl<TModel, TEmbedModel, TChatRequest, TEmbedRequest, TChatResponse, TChatResponseDelta, TEmbedResponse> {
-    createChatReq(req: Readonly<AxInternalChatRequest<TModel>>, config: Readonly<AxAIPromptConfig>): [AxAPI, TChatRequest];
+    createChatReq(req: Readonly<AxInternalChatRequest<TModel>>, config: Readonly<AxAIPromptConfig>): Promise<[AxAPI, TChatRequest]> | [AxAPI, TChatRequest];
     createChatResp(resp: Readonly<TChatResponse>): AxChatResponse;
     createChatStreamResp?(resp: Readonly<TChatResponseDelta>, state: object): AxChatResponse;
-    createEmbedReq?(req: Readonly<AxInternalEmbedRequest<TEmbedModel>>): [AxAPI, TEmbedRequest];
+    createEmbedReq?(req: Readonly<AxInternalEmbedRequest<TEmbedModel>>): Promise<[AxAPI, TEmbedRequest]> | [AxAPI, TEmbedRequest];
     createEmbedResp?(resp: Readonly<TEmbedResponse>): AxEmbedResponse;
     getModelConfig(): AxModelConfig;
     getTokenUsage(): AxTokenUsage | undefined;
 }
 
+interface AxAIFeatures {
+    functions: boolean;
+    streaming: boolean;
+    functionCot?: boolean;
+    hasThinkingBudget?: boolean;
+    hasShowThoughts?: boolean;
+}
+interface AxBaseAIArgs<TModel, TEmbedModel> {
+    name: string;
+    apiURL: string;
+    headers: () => Promise<Record<string, string>>;
+    modelInfo: Readonly<AxModelInfo[]>;
+    defaults: Readonly<{
+        model: TModel;
+        embedModel?: TEmbedModel;
+    }>;
+    options?: Readonly<AxAIServiceOptions>;
+    supportFor: AxAIFeatures | ((model: TModel) => AxAIFeatures);
+    models?: AxAIInputModelList<TModel, TEmbedModel>;
+}
+declare const axBaseAIDefaultConfig: () => AxModelConfig;
+declare const axBaseAIDefaultCreativeConfig: () => AxModelConfig;
+declare class AxBaseAI<TModel, TEmbedModel, TChatRequest, TEmbedRequest, TChatResponse, TChatResponseDelta, TEmbedResponse> implements AxAIService<TModel, TEmbedModel> {
+    private readonly aiImpl;
+    private debug;
+    private rt?;
+    private fetch?;
+    private tracer?;
+    private meter?;
+    private timeout?;
+    private excludeContentFromTrace?;
+    private models?;
+    private abortSignal?;
+    private logger;
+    private modelInfo;
+    private modelUsage?;
+    private embedModelUsage?;
+    private defaults;
+    private lastUsedModelConfig?;
+    private lastUsedChatModel?;
+    private lastUsedEmbedModel?;
+    protected apiURL: string;
+    protected name: string;
+    protected id: string;
+    protected headers: () => Promise<Record<string, string>>;
+    protected supportFor: AxAIFeatures | ((model: TModel) => AxAIFeatures);
+    private metrics;
+    constructor(aiImpl: Readonly<AxAIServiceImpl<TModel, TEmbedModel, TChatRequest, TEmbedRequest, TChatResponse, TChatResponseDelta, TEmbedResponse>>, { name, apiURL, headers, modelInfo, defaults, options, supportFor, models, }: Readonly<AxBaseAIArgs<TModel, TEmbedModel>>);
+    private getMetricsInstruments;
+    setName(name: string): void;
+    getId(): string;
+    setAPIURL(apiURL: string): void;
+    setHeaders(headers: () => Promise<Record<string, string>>): void;
+    setOptions(options: Readonly<AxAIServiceOptions>): void;
+    getOptions(): Readonly<AxAIServiceOptions>;
+    getLogger(): AxLoggerFunction;
+    getModelList(): AxAIModelList | undefined;
+    getName(): string;
+    getFeatures(model?: TModel): AxAIFeatures;
+    getLastUsedChatModel(): TModel | undefined;
+    getLastUsedEmbedModel(): TEmbedModel | undefined;
+    getLastUsedModelConfig(): AxModelConfig | undefined;
+    private calculatePercentile;
+    private updateLatencyMetrics;
+    private updateErrorMetrics;
+    private recordTokenUsage;
+    private calculateRequestSize;
+    private calculateResponseSize;
+    private detectMultimodalContent;
+    private calculatePromptLength;
+    private calculateContextWindowUsage;
+    private estimateCost;
+    private estimateCostByName;
+    private recordFunctionCallMetrics;
+    private recordTimeoutMetric;
+    private recordAbortMetric;
+    private recordChatMetrics;
+    private recordEmbedMetrics;
+    getMetrics(): AxAIServiceMetrics;
+    chat(req: Readonly<AxChatRequest<TModel>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
+    private _chat1;
+    private cleanupFunctionSchema;
+    private _chat2;
+    embed(req: Readonly<AxEmbedRequest<TEmbedModel>>, options?: Readonly<AxAIServiceActionOptions<TModel, TEmbedModel>>): Promise<AxEmbedResponse>;
+    private _embed1;
+    private _embed2;
+    private buildHeaders;
+    private getModelByKey;
+    private getModel;
+    private getEmbedModel;
+}
+
 declare enum AxAIAnthropicModel {
     Claude4Opus = "claude-opus-4-20250514",
     Claude4Sonnet = "claude-sonnet-4-20250514",
@@ -673,7 +671,7 @@ declare const axAIAnthropicDefaultConfig: () => AxAIAnthropicConfig;
 declare const axAIAnthropicVertexDefaultConfig: () => AxAIAnthropicConfig;
 interface AxAIAnthropicArgs {
     name: 'anthropic';
-    apiKey?: string;
+    apiKey?: string | (() => Promise<string>);
     projectId?: string;
     region?: string;
     config?: Readonly<Partial<AxAIAnthropicConfig>>;
@@ -684,6 +682,8 @@ declare class AxAIAnthropic extends AxBaseAI<AxAIAnthropicModel | AxAIAnthropicV
     constructor({ apiKey, projectId, region, config, options, models, }: Readonly<Omit<AxAIAnthropicArgs, 'name'>>);
 }
 
+declare const axModelInfoAnthropic: AxModelInfo[];
+
 declare enum AxAIOpenAIModel {
     GPT4 = "gpt-4",
     GPT41 = "gpt-4.1",
@@ -969,6 +969,57 @@ declare class AxAIAzureOpenAI extends AxAIOpenAIBase<AxAIOpenAIModel, AxAIOpenAI
     constructor({ apiKey, resourceName, deploymentName, version, config, options, models, modelInfo, }: Readonly<Omit<AxAIAzureOpenAIArgs, 'name'>>);
 }
 
+/**
+ * Options for the balancer.
+ */
+type AxBalancerOptions = {
+    comparator?: (a: AxAIService, b: AxAIService) => number;
+    debug?: boolean;
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+    maxRetries?: number;
+};
+/**
+ * Balancer that rotates through services.
+ */
+declare class AxBalancer implements AxAIService<unknown, unknown> {
+    private services;
+    private currentServiceIndex;
+    private currentService;
+    private debug;
+    private initialBackoffMs;
+    private maxBackoffMs;
+    private maxRetries;
+    private serviceFailures;
+    constructor(services: readonly AxAIService[], options?: AxBalancerOptions);
+    getLastUsedChatModel(): unknown;
+    getLastUsedEmbedModel(): unknown;
+    getLastUsedModelConfig(): AxModelConfig | undefined;
+    /**
+     * Service comparator that respects the input order of services.
+     */
+    static inputOrderComparator: () => number;
+    /**
+     * Service comparator that sorts services by cost.
+     */
+    static metricComparator: (a: AxAIService, b: AxAIService) => number;
+    getModelList(): AxAIModelList | undefined;
+    private getNextService;
+    private reset;
+    getName(): string;
+    getId(): string;
+    getFeatures(model?: string): AxAIFeatures;
+    getMetrics(): AxAIServiceMetrics;
+    private canRetryService;
+    private handleFailure;
+    private handleSuccess;
+    chat(req: Readonly<AxChatRequest>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions> | undefined): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
+    embed(req: Readonly<AxEmbedRequest>, options?: Readonly<AxAIServiceActionOptions> | undefined): Promise<AxEmbedResponse>;
+    setOptions(options: Readonly<AxAIServiceOptions>): void;
+    getOptions(): Readonly<AxAIServiceOptions>;
+    getLogger(): AxLoggerFunction;
+}
+
 /**
  * Cohere: Models for text generation
  */
@@ -1081,6 +1132,8 @@ declare class AxAICohere extends AxBaseAI<AxAICohereModel, AxAICohereEmbedModel,
     constructor({ apiKey, config, options, models, }: Readonly<Omit<AxAICohereArgs, 'name'>>);
 }
 
+declare const axModelInfoCohere: AxModelInfo[];
+
 /**
  * DeepSeek: Models for text generation
  */
@@ -1098,6 +1151,8 @@ declare class AxAIDeepSeek extends AxAIOpenAIBase<AxAIDeepSeekModel, undefined>
     constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAIDeepSeekArgs, 'name'>>);
 }
 
+declare const axModelInfoDeepSeek: AxModelInfo[];
+
 declare enum AxAIGoogleGeminiModel {
     Gemini25Pro = "gemini-2.5-pro",
     Gemini25Flash = "gemini-2.5-flash",
@@ -1338,7 +1393,7 @@ interface AxAIGoogleGeminiOptionsTools {
 }
 interface AxAIGoogleGeminiArgs {
     name: 'google-gemini';
-    apiKey?: string;
+    apiKey?: string | (() => Promise<string>);
     projectId?: string;
     region?: string;
     endpointId?: string;
@@ -1354,6 +1409,11 @@ declare class AxAIGoogleGemini extends AxBaseAI<AxAIGoogleGeminiModel, AxAIGoogl
     constructor({ apiKey, projectId, region, endpointId, config, options, models, modelInfo, }: Readonly<Omit<AxAIGoogleGeminiArgs, 'name'>>);
 }
 
+/**
+ * AxAIGoogleGemini: Model information
+ */
+declare const axModelInfoGoogleGemini: AxModelInfo[];
+
 declare enum AxAIGroqModel {
     Llama3_8B = "llama3-8b-8192",
     Llama33_70B = "llama-3.3-70b-versatile",
@@ -1373,6 +1433,11 @@ declare class AxAIGroq extends AxAIOpenAIBase<AxAIGroqModel, undefined> {
     private newRateLimiter;
 }
 
+/**
+ * AxAIGroq: Model information
+ */
+declare const axModelInfoGroq: AxModelInfo[];
+
 declare enum AxAIHuggingFaceModel {
     MetaLlama270BChatHF = "meta-llama/Llama-2-70b-chat-hf"
 }
@@ -1420,10 +1485,42 @@ declare class AxAIHuggingFace extends AxBaseAI<AxAIHuggingFaceModel, unknown, Ax
     constructor({ apiKey, config, options, models, }: Readonly<Omit<AxAIHuggingFaceArgs, 'name'>>);
 }
 
-declare enum AxAIMistralModel {
-    Mistral7B = "open-mistral-7b",
-    Mistral8x7B = "open-mixtral-8x7b",
-    MistralSmall = "mistral-small-latest",
+/**
+ * HuggingFace: Model information
+ */
+declare const axModelInfoHuggingFace: AxModelInfo[];
+
+interface AxAIMetricsInstruments {
+    latencyHistogram?: Histogram;
+    errorCounter?: Counter;
+    requestCounter?: Counter;
+    tokenCounter?: Counter;
+    inputTokenCounter?: Counter;
+    outputTokenCounter?: Counter;
+    errorRateGauge?: Gauge;
+    meanLatencyGauge?: Gauge;
+    p95LatencyGauge?: Gauge;
+    p99LatencyGauge?: Gauge;
+    streamingRequestsCounter?: Counter;
+    functionCallsCounter?: Counter;
+    functionCallLatencyHistogram?: Histogram;
+    requestSizeHistogram?: Histogram;
+    responseSizeHistogram?: Histogram;
+    temperatureGauge?: Gauge;
+    maxTokensGauge?: Gauge;
+    estimatedCostCounter?: Counter;
+    promptLengthHistogram?: Histogram;
+    contextWindowUsageGauge?: Gauge;
+    timeoutsCounter?: Counter;
+    abortsCounter?: Counter;
+    thinkingBudgetUsageCounter?: Counter;
+    multimodalRequestsCounter?: Counter;
+}
+
+declare enum AxAIMistralModel {
+    Mistral7B = "open-mistral-7b",
+    Mistral8x7B = "open-mixtral-8x7b",
+    MistralSmall = "mistral-small-latest",
     MistralNemo = "mistral-nemo-latest",
     MistralLarge = "mistral-large-latest",
     Codestral = "codestral-latest",
@@ -1480,6 +1577,130 @@ declare class AxAIMistral extends AxAIOpenAIBase<AxAIMistralModel, AxAIMistralEm
     private updateMessages;
 }
 
+declare const axModelInfoMistral: AxModelInfo[];
+
+type AxMockAIServiceConfig = {
+    name?: string;
+    id?: string;
+    modelInfo?: Partial<AxModelInfoWithProvider>;
+    embedModelInfo?: AxModelInfoWithProvider;
+    features?: {
+        functions?: boolean;
+        streaming?: boolean;
+    };
+    models?: AxAIModelList;
+    options?: AxAIServiceOptions;
+    chatResponse?: AxChatResponse | ReadableStream<AxChatResponse> | (() => Promise<AxChatResponse | ReadableStream<AxChatResponse>>) | ((req: Readonly<AxChatRequest<unknown>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<unknown, unknown>>) => Promise<AxChatResponse | ReadableStream<AxChatResponse>>);
+    embedResponse?: AxEmbedResponse | ((req: Readonly<AxEmbedRequest>) => AxEmbedResponse | Promise<AxEmbedResponse>);
+    shouldError?: boolean;
+    errorMessage?: string;
+    latencyMs?: number;
+};
+declare class AxMockAIService implements AxAIService {
+    private readonly config;
+    private metrics;
+    constructor(config?: AxMockAIServiceConfig);
+    getLastUsedChatModel(): unknown;
+    getLastUsedEmbedModel(): unknown;
+    getLastUsedModelConfig(): AxModelConfig | undefined;
+    getName(): string;
+    getId(): string;
+    getFeatures(_model?: string): {
+        functions: boolean;
+        streaming: boolean;
+    };
+    getModelList(): AxAIModelList | undefined;
+    getMetrics(): AxAIServiceMetrics;
+    chat(req: Readonly<AxChatRequest<unknown>>, _options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<unknown, unknown>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
+    embed(req: Readonly<AxEmbedRequest>, _options?: Readonly<AxAIServiceActionOptions>): Promise<AxEmbedResponse>;
+    setOptions(options: Readonly<AxAIServiceOptions>): void;
+    getOptions(): Readonly<AxAIServiceOptions>;
+    getLogger(): AxLoggerFunction;
+    private updateMetrics;
+}
+
+type AxAIServiceListItem<TModel = unknown, TEmbedModel = unknown> = {
+    key: string;
+    service: AxAIService<TModel, TEmbedModel>;
+    description: string;
+    isInternal?: boolean;
+};
+declare class AxMultiServiceRouter implements AxAIService<string, string> {
+    private options?;
+    private lastUsedService?;
+    private services;
+    /**
+     * Constructs a new multi-service router.
+     * It validates that each service provides a unique set of model keys,
+     * then builds a lookup (map) for routing the chat/embed requests.
+     */
+    constructor(services: (AxAIServiceListItem<string, string> | AxAIService<string, string>)[]);
+    getLastUsedChatModel(): string | undefined;
+    getLastUsedEmbedModel(): string | undefined;
+    getLastUsedModelConfig(): AxModelConfig | undefined;
+    /**
+     * Delegates the chat call to the service matching the provided model key.
+     */
+    chat(req: Readonly<AxChatRequest<string>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<string, string>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
+    /**
+     * Delegates the embed call to the service matching the provided embed model key.
+     */
+    embed(req: Readonly<AxEmbedRequest<string>>, options?: Readonly<AxAIServiceActionOptions<string, string>>): Promise<AxEmbedResponse>;
+    /**
+     * Returns a composite ID built from the IDs of the underlying services.
+     */
+    getId(): string;
+    /**
+     * Returns the name of this router.
+     */
+    getName(): string;
+    /**
+     * Aggregates all available models across the underlying services.
+     */
+    getModelList(): AxAIModelList;
+    /**
+     * If a model key is provided, delegate to the corresponding service's features.
+     * Otherwise, returns a default feature set.
+     */
+    getFeatures(model?: string): {
+        functions: boolean;
+        streaming: boolean;
+        functionCot?: boolean;
+    };
+    /**
+     * Returns aggregated metrics from the underlying service.
+     * Uses the metrics from the last service that was used,
+     * or falls back to the first service if none has been used.
+     */
+    getMetrics(): AxAIServiceMetrics;
+    /**
+     * Sets options on all underlying services.
+     */
+    setOptions(options: Readonly<AxAIServiceOptions>): void;
+    /**
+     * Returns the options from the last used service,
+     * or falls back to the first service if none has been used.
+     */
+    getOptions(): Readonly<AxAIServiceOptions>;
+    /**
+     * Returns the logger from the last used service,
+     * or falls back to the first service if none has been used.
+     */
+    getLogger(): AxLoggerFunction;
+    /**
+     * Sets a service entry for a given key. This method is intended for testing purposes.
+     * @param key - The model key
+     * @param entry - The service entry to set
+     */
+    setServiceEntry(key: string, entry: {
+        isInternal?: boolean;
+        description: string;
+        model?: string;
+        embedModel?: string;
+        service: AxAIService<string, string>;
+    }): void;
+}
+
 type AxAIOllamaAIConfig = AxAIOpenAIConfig<string, string>;
 declare const axAIOllamaDefaultConfig: () => AxAIOllamaAIConfig;
 declare const axAIOllamaDefaultCreativeConfig: () => AxAIOllamaAIConfig;
@@ -1495,6 +1716,15 @@ declare class AxAIOllama extends AxAIOpenAIBase<string, string> {
     constructor({ apiKey, url, config, options, models, }: Readonly<Omit<AxAIOllamaArgs, 'name'>>);
 }
 
+/**
+ * OpenAI: Model information
+ */
+declare const axModelInfoOpenAI: AxModelInfo[];
+/**
+ * OpenAI: Model information
+ */
+declare const axModelInfoOpenAIResponses: AxModelInfo[];
+
 declare enum AxAIOpenAIResponsesModel {
     GPT4 = "gpt-4",
     GPT41 = "gpt-4.1",
@@ -1987,6 +2217,28 @@ interface AxAIOpenAIResponsesMCPToolCall extends AxAIOpenAIResponsesToolCallBase
 }
 type AxAIOpenAIResponsesToolCall = AxAIOpenAIResponsesFunctionCallItem | AxAIOpenAIResponsesFileSearchToolCall | AxAIOpenAIResponsesWebSearchToolCall | AxAIOpenAIResponsesComputerToolCall | AxAIOpenAIResponsesCodeInterpreterToolCall | AxAIOpenAIResponsesImageGenerationToolCall | AxAIOpenAIResponsesLocalShellToolCall | AxAIOpenAIResponsesMCPToolCall;
 
+declare class AxAIOpenAIResponsesImpl<TModel, TEmbedModel, // Kept for interface compatibility, but not used by this impl.
+TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> implements AxAIServiceImpl<TModel, TEmbedModel, Readonly<AxAIOpenAIResponsesRequest<TModel>>, // ChatReq (now ResponsesReq)
+Readonly<AxAIOpenAIEmbedRequest<TEmbedModel>>, // EmbedReq
+Readonly<AxAIOpenAIResponsesResponse>, // ChatResp (now ResponsesResp)
+Readonly<AxAIOpenAIResponsesResponseDelta>, // ChatRespDelta (now ResponsesRespDelta)
+Readonly<AxAIOpenAIEmbedResponse>> {
+    private readonly config;
+    private readonly streamingUsage;
+    private readonly responsesReqUpdater?;
+    private tokensUsed;
+    constructor(config: Readonly<AxAIOpenAIResponsesConfig<TModel, TEmbedModel>>, streamingUsage: boolean, // If /v1/responses supports include_usage for streams
+    responsesReqUpdater?: ResponsesReqUpdater<TModel, TResponsesReq> | undefined);
+    getTokenUsage(): Readonly<AxTokenUsage> | undefined;
+    getModelConfig(): Readonly<AxModelConfig>;
+    private mapInternalContentToResponsesInput;
+    private createResponsesReqInternalInput;
+    createChatReq(req: Readonly<AxInternalChatRequest<TModel>>, config: Readonly<AxAIPromptConfig>): [Readonly<AxAPI>, Readonly<AxAIOpenAIResponsesRequest<TModel>>];
+    createChatResp(resp: Readonly<AxAIOpenAIResponsesResponse>): Readonly<AxChatResponse>;
+    createChatStreamResp(streamEvent: Readonly<AxAIOpenAIResponsesResponseDelta>): Readonly<AxChatResponse>;
+    createEmbedReq(req: Readonly<AxInternalEmbedRequest<TEmbedModel>>): [AxAPI, AxAIOpenAIEmbedRequest<TEmbedModel>];
+}
+
 declare const axAIOpenAIResponsesDefaultConfig: () => AxAIOpenAIResponsesConfig<AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel>;
 declare const axAIOpenAIResponsesBestConfig: () => AxAIOpenAIResponsesConfig<AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel>;
 declare const axAIOpenAIResponsesCreativeConfig: () => AxAIOpenAIResponsesConfig<AxAIOpenAIResponsesModel, AxAIOpenAIEmbedModel>;
@@ -2107,6 +2359,11 @@ declare class AxAIReka extends AxBaseAI<AxAIRekaModel, undefined, AxAIRekaChatRe
     constructor({ apiKey, config, options, apiURL, modelInfo, models, }: Readonly<Omit<AxAIRekaArgs, 'name'>>);
 }
 
+/**
+ * OpenAI: Model information
+ */
+declare const axModelInfoReka: AxModelInfo[];
+
 type TogetherAIConfig = AxAIOpenAIConfig<string, unknown>;
 declare const axAITogetherDefaultConfig: () => TogetherAIConfig;
 type AxAITogetherArgs = AxAIOpenAIArgs<'together', string, unknown>;
@@ -2114,6 +2371,22 @@ declare class AxAITogether extends AxAIOpenAIBase<string, unknown> {
     constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAITogetherArgs, 'name'>>);
 }
 
+declare const axModelInfoTogether: AxModelInfo[];
+
+type AxChatRequestMessage = AxChatRequest['chatPrompt'][number];
+/**
+ * Validates a chat request message item to ensure it meets the required criteria
+ * @param item - The chat request message to validate
+ * @throws {Error} When validation fails with a descriptive error message
+ */
+declare function axValidateChatRequestMessage(item: AxChatRequestMessage): void;
+/**
+ * Validates a chat response result to ensure it meets the required criteria
+ * @param results - The chat response results to validate (single result or array)
+ * @throws {Error} When validation fails with a descriptive error message
+ */
+declare function axValidateChatResponseResult(results: Readonly<AxChatResponseResult[]> | Readonly<AxChatResponseResult>): void;
+
 type AxAIArgs = AxAIOpenAIArgs | AxAIOpenAIResponsesArgs | AxAIAzureOpenAIArgs | AxAITogetherArgs | AxAIAnthropicArgs | AxAIGroqArgs | AxAIGoogleGeminiArgs | AxAICohereArgs | AxAIHuggingFaceArgs | AxAIMistralArgs | AxAIDeepSeekArgs | AxAIOllamaArgs | AxAIRekaArgs;
 type AxAIModels = AxAIOpenAIModel | AxAIAnthropicModel | AxAIGroqModel | AxAIGoogleGeminiModel | AxAICohereModel | AxAIHuggingFaceModel | AxAIMistralModel | AxAIDeepSeekModel;
 type AxAIEmbedModels = AxAIOpenAIEmbedModel | AxAIGoogleGeminiEmbedModel | AxAICohereEmbedModel;
@@ -2189,54 +2462,199 @@ declare class AxAIGrok extends AxAIOpenAIBase<AxAIGrokModel, AxAIGrokEmbedModels
     constructor({ apiKey, config, options, models, modelInfo, }: Readonly<Omit<AxAIGrokArgs, 'name'>>);
 }
 
-type AxMemoryData = {
-    tags?: string[];
-    role: AxChatRequest['chatPrompt'][number]['role'];
-    updatable?: boolean;
-    chat: {
-        index: number;
-        value: Omit<AxChatRequest['chatPrompt'][number], 'role'>;
-    }[];
-}[];
-interface AxAIMemory {
-    addRequest(result: AxChatRequest['chatPrompt'], sessionId?: string): void;
-    addResponse(results: Readonly<AxChatResponseResult[]>, sessionId?: string): void;
-    updateResult(results: Readonly<AxChatResponseResult> & {
-        delta?: string;
-    }, sessionId?: string): void;
-    addFunctionResults(results: Readonly<AxFunctionResult[]>, sessionId?: string): void;
-    history(index: number, sessionId?: string): AxChatRequest['chatPrompt'];
-    reset(sessionId?: string): void;
-    getLast(sessionId?: string): AxMemoryData[number] | undefined;
-    addTag(name: string, sessionId?: string): void;
-    rewindToTag(name: string, sessionId?: string): AxMemoryData;
-}
+declare const axModelInfoGrok: AxModelInfo[];
 
-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;
+type AxDBUpsertRequest = {
+    id: string;
+    text?: string;
+    values?: readonly number[];
+    metadata?: Record<string, string>;
+    table: string;
+    namespace?: string;
 };
-interface AxSignatureConfig {
-    description?: string;
-    inputs: readonly AxField[];
-    outputs: readonly AxField[];
-}
-declare class AxSignature {
-    private description?;
-    private inputFields;
-    private outputFields;
-    private sigHash;
+type AxDBUpsertResponse = {
+    ids: string[];
+};
+type AxDBQueryRequest = {
+    id?: string;
+    text?: string;
+    values?: readonly number[];
+    table: string;
+    columns?: string[];
+    limit?: number;
+    namespace?: string;
+};
+type AxDBQueryResponse = {
+    matches: {
+        id: string;
+        score: number;
+        metadata?: Record<string, string>;
+        table?: string;
+    }[];
+};
+interface AxDBService extends AxDBQueryService {
+    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
+    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
+}
+interface AxDBQueryService {
+    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
+}
+
+interface AxDBBaseArgs {
+    fetch?: typeof fetch;
+    tracer?: Tracer;
+}
+interface AxDBBaseOpOptions {
+    span?: Span;
+}
+declare class AxDBBase implements AxDBService {
+    protected name: string;
+    protected fetch?: typeof fetch;
+    private tracer?;
+    _upsert?: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
+    _batchUpsert?: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
+    _query?: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBQueryResponse>;
+    constructor({ name, fetch, tracer, }: Readonly<AxDBBaseArgs & {
+        name: string;
+    }>);
+    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
+    batchUpsert(req: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
+    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
+}
+
+type AxDBCloudflareOpOptions = AxDBBaseOpOptions;
+interface AxDBCloudflareArgs extends AxDBBaseArgs {
+    name: 'cloudflare';
+    apiKey: string;
+    accountId: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Cloudflare: DB Service
+ */
+declare class AxDBCloudflare extends AxDBBase {
+    private apiKey;
+    private accountId;
+    constructor({ apiKey, accountId, fetch, tracer, }: Readonly<Omit<AxDBCloudflareArgs, 'name'>>);
+    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
+    batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
+    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBQueryResponse>;
+}
+
+type AxDBMemoryOpOptions = AxDBBaseOpOptions;
+interface AxDBMemoryArgs extends AxDBBaseArgs {
+    name: 'memory';
+}
+type AxDBState = Record<string, Record<string, AxDBUpsertRequest>>;
+/**
+ * MemoryDB: DB Service
+ */
+declare class AxDBMemory extends AxDBBase {
+    private state;
+    constructor({ tracer }?: Readonly<Omit<AxDBMemoryArgs, 'name'>>);
+    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
+    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
+    _query: (req: Readonly<AxDBQueryRequest>, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBQueryResponse>;
+    getDB: () => AxDBState;
+    setDB: (state: AxDBState) => void;
+    clearDB: () => void;
+}
+
+type AxDBPineconeOpOptions = AxDBBaseOpOptions;
+interface AxDBPineconeArgs extends AxDBBaseArgs {
+    name: 'pinecone';
+    apiKey: string;
+    host: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Pinecone: DB Service
+ */
+declare class AxDBPinecone extends AxDBBase {
+    private apiKey;
+    private apiURL;
+    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBPineconeArgs, 'name'>>);
+    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
+    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, _update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
+    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBQueryResponse>;
+}
+
+type AxDBWeaviateOpOptions = AxDBBaseOpOptions;
+interface AxDBWeaviateArgs extends AxDBBaseArgs {
+    name: 'weaviate';
+    apiKey: string;
+    host: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Weaviate: DB Service
+ */
+declare class AxDBWeaviate extends AxDBBase {
+    private apiKey;
+    private apiURL;
+    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBWeaviateArgs, 'name'>>);
+    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
+    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
+    _query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBQueryResponse>;
+}
+
+type AxDBArgs = AxDBCloudflareArgs | AxDBPineconeArgs | AxDBWeaviateArgs | AxDBMemoryArgs;
+declare class AxDB implements AxDBService {
+    private db;
+    constructor(args: Readonly<AxDBArgs>);
+    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
+    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
+    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
+}
+
+type AxMemoryData = {
+    tags?: string[];
+    role: AxChatRequest['chatPrompt'][number]['role'];
+    updatable?: boolean;
+    chat: {
+        index: number;
+        value: Omit<AxChatRequest['chatPrompt'][number], 'role'>;
+    }[];
+}[];
+interface AxAIMemory {
+    addRequest(result: AxChatRequest['chatPrompt'], sessionId?: string): void;
+    addResponse(results: Readonly<AxChatResponseResult[]>, sessionId?: string): void;
+    updateResult(results: Readonly<AxChatResponseResult> & {
+        delta?: string;
+    }, sessionId?: string): void;
+    addFunctionResults(results: Readonly<AxFunctionResult[]>, sessionId?: string): void;
+    history(index: number, sessionId?: string): AxChatRequest['chatPrompt'];
+    reset(sessionId?: string): void;
+    getLast(sessionId?: string): AxMemoryData[number] | undefined;
+    addTag(name: string, sessionId?: string): void;
+    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>);
@@ -2579,77 +2997,148 @@ declare class AxProgram<IN extends AxGenIn, OUT extends AxGenOut> implements AxT
     setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
 }
 
-/**
- * Interface for agents that can be used as child agents.
- * Provides methods to get the agent's function definition and features.
- */
-interface AxAgentic<IN extends AxGenIn, OUT extends AxGenOut> extends AxTunable<IN, OUT>, AxUsable {
-    getFunction(): AxFunction;
-    getFeatures(): AxAgentFeatures;
-}
-type AxAgentOptions = Omit<AxProgramForwardOptions, 'functions'> & {
-    disableSmartModelRouting?: boolean;
-    /** List of field names that should not be automatically passed from parent to child agents */
-    excludeFieldsFromPassthrough?: string[];
-    debug?: boolean;
+type AxRewriteIn = {
+    query: string;
 };
-interface AxAgentFeatures {
-    /** Whether this agent can use smart model routing (requires an AI service) */
-    canConfigureSmartModelRouting: boolean;
-    /** List of fields that this agent excludes from parent->child value passing */
-    excludeFieldsFromPassthrough: string[];
+type AxRewriteOut = {
+    rewrittenQuery: string;
+};
+type AxRerankerIn = {
+    query: string;
+    items: string[];
+};
+type AxRerankerOut = {
+    rankedItems: string[];
+};
+interface AxDBLoaderOptions {
+    chunker?: (text: string) => string[];
+    rewriter?: AxProgram<AxRewriteIn, AxRewriteOut>;
+    reranker?: AxProgram<AxRerankerIn, AxRerankerOut>;
 }
-/**
- * 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.
- */
-declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAgentic<IN, OUT> {
-    private ai?;
-    private program;
-    private functions?;
-    private agents?;
-    private disableSmartModelRouting?;
-    private excludeFieldsFromPassthrough;
-    private debug?;
-    private name;
-    private func;
-    constructor({ ai, name, description, definition, signature, agents, functions, }: Readonly<{
-        ai?: Readonly<AxAIService>;
-        name: string;
-        description: string;
-        definition?: string;
-        signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>;
-        agents?: AxAgentic<IN, OUT>[];
-        functions?: AxInputFunctionType;
-    }>, options?: Readonly<AxAgentOptions>);
-    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
-    setId(id: string): void;
-    setParentId(parentId: string): void;
-    getTraces(): AxProgramTrace<IN, OUT>[];
-    setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
-    getUsage(): (AxModelUsage & {
-        ai: string;
-        model: string;
-    })[];
-    resetUsage(): void;
-    getFunction(): AxFunction;
-    getFeatures(): AxAgentFeatures;
-    /**
-     * Initializes the agent's execution context, processing child agents and their functions.
-     */
-    private init;
-    forward(parentAi: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
-    streamingForward(parentAi: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
+interface AxDBManagerArgs {
+    ai: AxAIService;
+    db: AxDBService;
+    config?: AxDBLoaderOptions;
+}
+interface AxDBMatch {
+    score: number;
+    text: string;
+}
+declare class AxDBManager {
+    private ai;
+    private db;
+    private chunker;
+    private rewriter?;
+    private reranker?;
+    constructor({ ai, db, config }: Readonly<AxDBManagerArgs>);
+    private defaultChunker;
+    insert: (text: Readonly<string | string[]>, options?: Readonly<{
+        batchSize?: number;
+        maxWordsPerChunk?: number;
+        minWordsPerChunk?: number;
+        abortSignal?: AbortSignal;
+    }>) => Promise<void>;
+    query: (query: Readonly<string | string[] | number | number[]>, { topPercent, abortSignal, }?: Readonly<{
+        topPercent?: number;
+        abortSignal?: AbortSignal;
+    }> | undefined) => Promise<AxDBMatch[][]>;
+}
+
+type AxFieldProcessorProcess = (value: AxFieldValue, context?: Readonly<{
+    values?: AxGenOut;
+    sessionId?: string;
+    done?: boolean;
+}>) => unknown | Promise<unknown>;
+type AxStreamingFieldProcessorProcess = (value: string, context?: Readonly<{
+    values?: AxGenOut;
+    sessionId?: string;
+    done?: boolean;
+}>) => unknown | Promise<unknown>;
+interface AxFieldProcessor {
+    field: Readonly<AxField>;
     /**
-     * Updates the agent's description.
-     * This updates both the stored description and the function's description.
-     *
-     * @param description - New description for the agent (must be at least 20 characters)
-     * @throws Error if description is too short
+     * Process the field value and return a new value (or undefined if no update is needed).
+     * The returned value may be merged back into memory.
+     * @param value - The current field value.
+     * @param context - Additional context (e.g. memory and session id).
      */
-    setDescription(description: string): void;
-    setDefinition(definition: string): void;
-    private getDebug;
+    process: AxFieldProcessorProcess | AxStreamingFieldProcessorProcess;
+}
+
+type AxGenerateResult<OUT extends AxGenOut> = OUT & {
+    thought?: string;
+};
+interface AxResponseHandlerArgs<T> {
+    ai: Readonly<AxAIService>;
+    model?: string;
+    res: T;
+    mem: AxAIMemory;
+    sessionId?: string;
+    traceId?: string;
+    functions: Readonly<AxFunction[]>;
+    strictMode?: boolean;
+    span?: Span;
+}
+interface AxStreamingEvent<T> {
+    event: 'delta' | 'done' | 'error';
+    data: {
+        contentDelta?: string;
+        partialValues?: Partial<T>;
+        error?: string;
+        functions?: AxChatResponseFunctionCall[];
+    };
+}
+declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxProgram<IN, OUT> {
+    private promptTemplate;
+    private asserts;
+    private streamingAsserts;
+    private options?;
+    private functions?;
+    private fieldProcessors;
+    private streamingFieldProcessors;
+    private excludeContentFromTrace;
+    private thoughtFieldName;
+    constructor(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: Readonly<AxProgramForwardOptions>);
+    private getSignatureName;
+    private getMetricsInstruments;
+    updateMeter(meter?: Meter): void;
+    private createStates;
+    addAssert: (fn: AxAssertion["fn"], message?: string) => void;
+    addStreamingAssert: (fieldName: string, fn: AxStreamingAssertion["fn"], message?: string) => void;
+    private addFieldProcessorInternal;
+    addStreamingFieldProcessor: (fieldName: string, fn: AxFieldProcessor["process"]) => void;
+    addFieldProcessor: (fieldName: string, fn: AxFieldProcessor["process"]) => void;
+    private forwardSendRequest;
+    private forwardCore;
+    private _forward2;
+    _forward1(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options: Readonly<AxProgramForwardOptions>): AxGenStreamingOut<OUT>;
+    forward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
+    streamingForward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
+    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
+    private isDebug;
+    private getLogger;
+}
+type AxGenerateErrorDetails = {
+    model?: string;
+    maxTokens?: number;
+    streaming: boolean;
+    signature: {
+        input: Readonly<AxIField[]>;
+        output: Readonly<AxIField[]>;
+        description?: string;
+    };
+};
+type ErrorOptions = {
+    cause?: Error;
+};
+declare class AxGenerateError extends Error {
+    readonly details: AxGenerateErrorDetails;
+    constructor(message: string, details: Readonly<AxGenerateErrorDetails>, options?: ErrorOptions);
+}
+
+declare class AxDefaultResultReranker extends AxGen<AxRerankerIn, AxRerankerOut> {
+    constructor(options?: Readonly<AxProgramForwardOptions>);
+    forward: (ai: Readonly<AxAIService>, input: Readonly<AxRerankerIn>, options?: Readonly<AxProgramForwardOptions>) => Promise<AxRerankerOut>;
 }
 
 interface AxApacheTikaArgs {
@@ -2670,56 +3159,75 @@ declare class AxApacheTika {
     }>): Promise<string[]>;
 }
 
+interface AxSimpleClassifierForwardOptions {
+    cutoff?: number;
+    abortSignal?: AbortSignal;
+}
+declare class AxSimpleClassifierClass {
+    private readonly name;
+    private readonly context;
+    constructor(name: string, context: readonly string[]);
+    getName(): string;
+    getContext(): readonly string[];
+}
+declare class AxSimpleClassifier {
+    private readonly ai;
+    private db;
+    private debug?;
+    constructor(ai: AxAIService);
+    getState(): AxDBState | undefined;
+    setState(state: AxDBState): void;
+    setClasses: (classes: readonly AxSimpleClassifierClass[], options?: Readonly<{
+        abortSignal?: AbortSignal;
+    }>) => Promise<void>;
+    forward(text: string, options?: Readonly<AxSimpleClassifierForwardOptions>): Promise<string>;
+    setOptions(options: Readonly<{
+        debug?: boolean;
+    }>): void;
+}
+
 /**
- * Options for the balancer.
+ * Calculates the Exact Match (EM) score between a prediction and ground truth.
+ *
+ * The EM score is a strict metric used in machine learning to assess if the predicted
+ * answer matches the ground truth exactly, commonly used in tasks like question answering.
+ *
+ * @param prediction The predicted text.
+ * @param groundTruth The actual correct text.
+ * @returns A number (1.0 for exact match, 0.0 otherwise).
  */
-type AxBalancerOptions = {
-    comparator?: (a: AxAIService, b: AxAIService) => number;
-    debug?: boolean;
-    initialBackoffMs?: number;
-    maxBackoffMs?: number;
-    maxRetries?: number;
-};
+declare function emScore(prediction: string, groundTruth: string): number;
 /**
- * Balancer that rotates through services.
+ * Calculates the F1 score between a prediction and ground truth.
+ *
+ * The F1 score is a harmonic mean of precision and recall, widely used in NLP to measure
+ * a model's accuracy in considering both false positives and false negatives, offering a
+ * balance for evaluating classification models.
+ *
+ * @param prediction The predicted text.
+ * @param groundTruth The actual correct text.
+ * @returns The F1 score as a number.
  */
-declare class AxBalancer implements AxAIService<unknown, unknown> {
-    private services;
-    private currentServiceIndex;
-    private currentService;
-    private debug;
-    private initialBackoffMs;
-    private maxBackoffMs;
-    private maxRetries;
-    private serviceFailures;
-    constructor(services: readonly AxAIService[], options?: AxBalancerOptions);
-    getLastUsedChatModel(): unknown;
-    getLastUsedEmbedModel(): unknown;
-    getLastUsedModelConfig(): AxModelConfig | undefined;
-    /**
-     * Service comparator that respects the input order of services.
-     */
-    static inputOrderComparator: () => number;
-    /**
-     * Service comparator that sorts services by cost.
-     */
-    static metricComparator: (a: AxAIService, b: AxAIService) => number;
-    getModelList(): AxAIModelList | undefined;
-    private getNextService;
-    private reset;
-    getName(): string;
-    getId(): string;
-    getFeatures(model?: string): AxAIFeatures;
-    getMetrics(): AxAIServiceMetrics;
-    private canRetryService;
-    private handleFailure;
-    private handleSuccess;
-    chat(req: Readonly<AxChatRequest>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions> | undefined): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
-    embed(req: Readonly<AxEmbedRequest>, options?: Readonly<AxAIServiceActionOptions> | undefined): Promise<AxEmbedResponse>;
-    setOptions(options: Readonly<AxAIServiceOptions>): void;
-    getOptions(): Readonly<AxAIServiceOptions>;
-    getLogger(): AxLoggerFunction;
-}
+declare function f1Score(prediction: string, groundTruth: string): number;
+/**
+ * Calculates a novel F1 score, taking into account a history of interaction and excluding stopwords.
+ *
+ * This metric extends the F1 score by considering contextual relevance and filtering out common words
+ * that might skew the assessment of the prediction's quality, especially in conversational models or
+ * when historical context is relevant.
+ *
+ * @param history The historical context or preceding interactions.
+ * @param prediction The predicted text.
+ * @param groundTruth The actual correct text.
+ * @param returnRecall Optionally return the recall score instead of F1.
+ * @returns The novel F1 or recall score as a number.
+ */
+declare function novelF1ScoreOptimized(history: string, prediction: string, groundTruth: string, returnRecall?: boolean): number;
+declare const AxEvalUtil: {
+    emScore: typeof emScore;
+    f1Score: typeof f1Score;
+    novelF1ScoreOptimized: typeof novelF1ScoreOptimized;
+};
 
 type AxExample = Record<string, AxFieldValue>;
 type AxMetricFn = <T extends AxGenOut = AxGenOut>(arg0: Readonly<{
@@ -3243,1411 +3751,828 @@ declare abstract class AxBaseOptimizer<IN extends AxGenIn = AxGenIn, OUT extends
     protected recordPerformanceMetrics(metricType: 'evaluation' | 'demo_generation' | 'metric_computation', duration: number, optimizerType: string): void;
 }
 
-type AxDBUpsertRequest = {
-    id: string;
-    text?: string;
-    values?: readonly number[];
-    metadata?: Record<string, string>;
-    table: string;
-    namespace?: string;
+type AxEvaluateArgs<IN extends AxGenIn, OUT extends AxGenOut> = {
+    ai: AxAIService;
+    program: Readonly<AxProgram<IN, OUT>>;
+    examples: Readonly<AxExample[]>;
 };
-type AxDBUpsertResponse = {
-    ids: string[];
-};
-type AxDBQueryRequest = {
-    id?: string;
-    text?: string;
-    values?: readonly number[];
-    table: string;
-    columns?: string[];
-    limit?: number;
-    namespace?: string;
-};
-type AxDBQueryResponse = {
-    matches: {
-        id: string;
-        score: number;
-        metadata?: Record<string, string>;
-        table?: string;
-    }[];
-};
-interface AxDBService extends AxDBQueryService {
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-}
-interface AxDBQueryService {
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
+declare class AxTestPrompt<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> {
+    private ai;
+    private program;
+    private examples;
+    constructor({ ai, program, examples, }: Readonly<AxEvaluateArgs<IN, OUT>>);
+    run(metricFn: AxMetricFn): Promise<void>;
 }
 
-interface AxDBBaseArgs {
-    fetch?: typeof fetch;
-    tracer?: Tracer;
-}
-interface AxDBBaseOpOptions {
-    span?: Span;
-}
-declare class AxDBBase implements AxDBService {
-    protected name: string;
-    protected fetch?: typeof fetch;
-    private tracer?;
-    _upsert?: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert?: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query?: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBBaseOpOptions>) => Promise<AxDBQueryResponse>;
-    constructor({ name, fetch, tracer, }: Readonly<AxDBBaseArgs & {
-        name: string;
-    }>);
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(req: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
-}
+declare const axGlobals: {
+    signatureStrict: boolean;
+    tracer: Tracer | undefined;
+    meter: Meter | undefined;
+};
 
-type AxDBCloudflareOpOptions = AxDBBaseOpOptions;
-interface AxDBCloudflareArgs extends AxDBBaseArgs {
-    name: 'cloudflare';
-    apiKey: string;
-    accountId: string;
-    fetch?: typeof fetch;
-}
-/**
- * Cloudflare: DB Service
- */
-declare class AxDBCloudflare extends AxDBBase {
-    private apiKey;
-    private accountId;
-    constructor({ apiKey, accountId, fetch, tracer, }: Readonly<Omit<AxDBCloudflareArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
-    batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBUpsertResponse>;
-    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBCloudflareOpOptions>) => Promise<AxDBQueryResponse>;
+type AxDataRow = {
+    row: Record<string, AxFieldValue>;
+};
+declare class AxHFDataLoader {
+    private rows;
+    private baseUrl;
+    private dataset;
+    private split;
+    private config;
+    private options?;
+    constructor({ dataset, split, config, options, }: Readonly<{
+        dataset: string;
+        split: string;
+        config: string;
+        options?: Readonly<{
+            offset?: number;
+            length?: number;
+        }>;
+    }>);
+    private fetchDataFromAPI;
+    loadData(): Promise<AxDataRow[]>;
+    setData(rows: AxDataRow[]): void;
+    getData(): AxDataRow[];
+    getRows<T>({ count, fields, renameMap, }: Readonly<{
+        count: number;
+        fields: readonly string[];
+        renameMap?: Record<string, string>;
+    }>): Promise<T[]>;
 }
 
-type AxDBMemoryOpOptions = AxDBBaseOpOptions;
-interface AxDBMemoryArgs extends AxDBBaseArgs {
-    name: 'memory';
-}
-type AxDBState = Record<string, Record<string, AxDBUpsertRequest>>;
+declare const axCreateDefaultColorLogger: (output?: (message: string) => void) => AxLoggerFunction;
+declare const axCreateDefaultTextLogger: (output?: (message: string) => void) => AxLoggerFunction;
 /**
- * MemoryDB: DB Service
+ * Factory function to create an enhanced optimizer logger with clean visual formatting
+ * that works for all optimizer types using semantic tags for proper categorization
  */
-declare class AxDBMemory extends AxDBBase {
-    private state;
-    constructor({ tracer }?: Readonly<Omit<AxDBMemoryArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, _update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query: (req: Readonly<AxDBQueryRequest>, _options?: Readonly<AxDBMemoryOpOptions>) => Promise<AxDBQueryResponse>;
-    getDB: () => AxDBState;
-    setDB: (state: AxDBState) => void;
-    clearDB: () => void;
-}
-
-type AxDBPineconeOpOptions = AxDBBaseOpOptions;
-interface AxDBPineconeArgs extends AxDBBaseArgs {
-    name: 'pinecone';
-    apiKey: string;
-    host: string;
-    fetch?: typeof fetch;
-}
+declare const axCreateOptimizerLogger: (output?: (message: string) => void) => AxLoggerFunction;
 /**
- * Pinecone: DB Service
+ * Default optimizer logger instance
  */
-declare class AxDBPinecone extends AxDBBase {
-    private apiKey;
-    private apiURL;
-    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBPineconeArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, _update?: boolean, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBUpsertResponse>;
-    query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBPineconeOpOptions>) => Promise<AxDBQueryResponse>;
-}
+declare const axDefaultOptimizerLogger: AxLoggerFunction;
 
-type AxDBWeaviateOpOptions = AxDBBaseOpOptions;
-interface AxDBWeaviateArgs extends AxDBBaseArgs {
-    name: 'weaviate';
-    apiKey: string;
-    host: string;
-    fetch?: typeof fetch;
+interface AxMetricsConfig {
+    enabled: boolean;
+    enabledCategories: ('generation' | 'streaming' | 'functions' | 'errors' | 'performance')[];
+    maxLabelLength: number;
+    samplingRate: number;
 }
-/**
- * Weaviate: DB Service
- */
-declare class AxDBWeaviate extends AxDBBase {
-    private apiKey;
-    private apiURL;
-    constructor({ apiKey, host, fetch, tracer, }: Readonly<Omit<AxDBWeaviateArgs, 'name'>>);
-    _upsert: (req: Readonly<AxDBUpsertRequest>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
-    _batchUpsert: (batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBUpsertResponse>;
-    _query: (req: Readonly<AxDBQueryRequest>, options?: Readonly<AxDBWeaviateOpOptions>) => Promise<AxDBQueryResponse>;
+declare const axDefaultMetricsConfig: AxMetricsConfig;
+type AxErrorCategory = 'validation_error' | 'assertion_error' | 'timeout_error' | 'abort_error' | 'network_error' | 'auth_error' | 'rate_limit_error' | 'function_error' | 'parsing_error' | 'unknown_error';
+interface AxGenMetricsInstruments {
+    generationLatencyHistogram?: Histogram;
+    generationRequestsCounter?: Counter;
+    generationErrorsCounter?: Counter;
+    multiStepGenerationsCounter?: Counter;
+    stepsPerGenerationHistogram?: Histogram;
+    maxStepsReachedCounter?: Counter;
+    validationErrorsCounter?: Counter;
+    assertionErrorsCounter?: Counter;
+    errorCorrectionAttemptsHistogram?: Histogram;
+    errorCorrectionSuccessCounter?: Counter;
+    errorCorrectionFailureCounter?: Counter;
+    maxRetriesReachedCounter?: Counter;
+    functionsEnabledGenerationsCounter?: Counter;
+    functionCallStepsCounter?: Counter;
+    functionsExecutedPerGenerationHistogram?: Histogram;
+    functionErrorCorrectionCounter?: Counter;
+    fieldProcessorsExecutedCounter?: Counter;
+    streamingFieldProcessorsExecutedCounter?: Counter;
+    streamingGenerationsCounter?: Counter;
+    streamingDeltasEmittedCounter?: Counter;
+    streamingFinalizationLatencyHistogram?: Histogram;
+    samplesGeneratedHistogram?: Histogram;
+    resultPickerUsageCounter?: Counter;
+    resultPickerLatencyHistogram?: Histogram;
+    inputFieldsGauge?: Gauge;
+    outputFieldsGauge?: Gauge;
+    examplesUsedGauge?: Gauge;
+    demosUsedGauge?: Gauge;
+    promptRenderLatencyHistogram?: Histogram;
+    extractionLatencyHistogram?: Histogram;
+    assertionLatencyHistogram?: Histogram;
+    stateCreationLatencyHistogram?: Histogram;
+    memoryUpdateLatencyHistogram?: Histogram;
 }
+declare const axCheckMetricsHealth: () => {
+    healthy: boolean;
+    issues: string[];
+};
+declare const axUpdateMetricsConfig: (config: Readonly<Partial<AxMetricsConfig>>) => void;
+declare const axGetMetricsConfig: () => AxMetricsConfig;
 
-type AxDBArgs = AxDBCloudflareArgs | AxDBPineconeArgs | AxDBWeaviateArgs | AxDBMemoryArgs;
-declare class AxDB implements AxDBService {
-    private db;
-    constructor(args: Readonly<AxDBArgs>);
-    upsert(req: Readonly<AxDBUpsertRequest>, update?: boolean): Promise<AxDBUpsertResponse>;
-    batchUpsert(batchReq: Readonly<AxDBUpsertRequest[]>, update?: boolean): Promise<AxDBUpsertResponse>;
-    query(req: Readonly<AxDBQueryRequest>): Promise<AxDBQueryResponse>;
+declare class AxBootstrapFewShot<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
+    private maxRounds;
+    private maxDemos;
+    private maxExamples;
+    private batchSize;
+    private earlyStoppingPatience;
+    private costMonitoring;
+    private maxTokensPerGeneration;
+    private verboseMode;
+    private debugMode;
+    private traces;
+    constructor(args: Readonly<AxOptimizerArgs & {
+        options?: AxBootstrapOptimizerOptions;
+    }>);
+    private compileRound;
+    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxBootstrapCompileOptions): Promise<AxOptimizerResult<OUT>>;
 }
 
-type AxRewriteIn = {
-    query: string;
-};
-type AxRewriteOut = {
-    rewrittenQuery: string;
-};
-type AxRerankerIn = {
-    query: string;
-    items: string[];
-};
-type AxRerankerOut = {
-    rankedItems: string[];
-};
-interface AxDBLoaderOptions {
-    chunker?: (text: string) => string[];
-    rewriter?: AxProgram<AxRewriteIn, AxRewriteOut>;
-    reranker?: AxProgram<AxRerankerIn, AxRerankerOut>;
-}
-interface AxDBManagerArgs {
-    ai: AxAIService;
-    db: AxDBService;
-    config?: AxDBLoaderOptions;
-}
-interface AxDBMatch {
-    score: number;
-    text: string;
+interface AxMiPROResult<IN extends AxGenIn, OUT extends AxGenOut> extends AxOptimizerResult<OUT> {
+    optimizedGen?: AxGen<IN, OUT>;
 }
-declare class AxDBManager {
-    private ai;
-    private db;
-    private chunker;
-    private rewriter?;
-    private reranker?;
-    constructor({ ai, db, config }: Readonly<AxDBManagerArgs>);
-    private defaultChunker;
-    insert: (text: Readonly<string | string[]>, options?: Readonly<{
-        batchSize?: number;
-        maxWordsPerChunk?: number;
-        minWordsPerChunk?: number;
-        abortSignal?: AbortSignal;
-    }>) => Promise<void>;
-    query: (query: Readonly<string | string[] | number | number[]>, { topPercent, abortSignal, }?: Readonly<{
-        topPercent?: number;
-        abortSignal?: AbortSignal;
-    }> | undefined) => Promise<AxDBMatch[][]>;
-}
-
-interface AxDockerContainer {
-    Id: string;
-    Names: string[];
-    Image: string;
-    ImageID: string;
-    Command: string;
-    Created: number;
-    State: {
-        Status: string;
-        Running: boolean;
-        Paused: boolean;
-        Restarting: boolean;
-        OOMKilled: boolean;
-        Dead: boolean;
-        Pid: number;
-        ExitCode: number;
-        Error: string;
-        StartedAt: Date;
-        FinishedAt: Date;
-    };
-    Status: string;
-    Ports: Array<{
-        IP: string;
-        PrivatePort: number;
-        PublicPort: number;
-        Type: string;
-    }>;
-    Labels: {
-        [key: string]: string;
-    };
-    SizeRw: number;
-    SizeRootFs: number;
-    HostConfig: {
-        NetworkMode: string;
-    };
-    NetworkSettings: {
-        Networks: {
-            [key: string]: {
-                IPAddress: string;
-                IPPrefixLen: number;
-                Gateway: string;
-                MacAddress: string;
-            };
-        };
-    };
-    Mounts: Array<{
-        Type: string;
-        Source: string;
-        Destination: string;
-        Mode: string;
-        RW: boolean;
-        Propagation: string;
-    }>;
-}
-declare class AxDockerSession {
-    private readonly apiUrl;
-    private containerId;
-    constructor(apiUrl?: string);
-    pullImage(imageName: string): Promise<void>;
-    createContainer({ imageName, volumes, doNotPullImage, tag, }: Readonly<{
-        imageName: string;
-        volumes?: Array<{
-            hostPath: string;
-            containerPath: string;
-        }>;
-        doNotPullImage?: boolean;
-        tag?: string;
-    }>): Promise<{
-        Id: string;
-    }>;
-    findOrCreateContainer({ imageName, volumes, doNotPullImage, tag, }: Readonly<{
-        imageName: string;
-        volumes?: Array<{
-            hostPath: string;
-            containerPath: string;
-        }>;
-        doNotPullImage?: boolean;
-        tag: string;
-    }>): Promise<{
-        Id: string;
-        isNew: boolean;
-    }>;
-    startContainer(): Promise<void>;
-    connectToContainer(containerId: string): Promise<void>;
-    stopContainers({ tag, remove, timeout, }: Readonly<{
-        tag?: string;
-        remove?: boolean;
-        timeout?: number;
-    }>): Promise<Array<{
-        Id: string;
-        Action: 'stopped' | 'removed';
-    }>>;
-    listContainers(all?: boolean): Promise<AxDockerContainer[]>;
-    getContainerLogs(): Promise<string>;
-    executeCommand(command: string): Promise<string>;
-    private getContainerInfo;
-    private waitForContainerToBeRunning;
-    private fetchDockerAPI;
-    toFunction(): AxFunction;
-}
-
-type AxFieldProcessorProcess = (value: AxFieldValue, context?: Readonly<{
-    values?: AxGenOut;
-    sessionId?: string;
-    done?: boolean;
-}>) => unknown | Promise<unknown>;
-type AxStreamingFieldProcessorProcess = (value: string, context?: Readonly<{
-    values?: AxGenOut;
-    sessionId?: string;
-    done?: boolean;
-}>) => unknown | Promise<unknown>;
-interface AxFieldProcessor {
-    field: Readonly<AxField>;
-    /**
-     * Process the field value and return a new value (or undefined if no update is needed).
-     * The returned value may be merged back into memory.
-     * @param value - The current field value.
-     * @param context - Additional context (e.g. memory and session id).
-     */
-    process: AxFieldProcessorProcess | AxStreamingFieldProcessorProcess;
-}
-
-type AxGenerateResult<OUT extends AxGenOut> = OUT & {
-    thought?: string;
-};
-interface AxResponseHandlerArgs<T> {
-    ai: Readonly<AxAIService>;
-    model?: string;
-    res: T;
-    mem: AxAIMemory;
-    sessionId?: string;
-    traceId?: string;
-    functions: Readonly<AxFunction[]>;
-    strictMode?: boolean;
-    span?: Span;
-}
-interface AxStreamingEvent<T> {
-    event: 'delta' | 'done' | 'error';
-    data: {
-        contentDelta?: string;
-        partialValues?: Partial<T>;
-        error?: string;
-        functions?: AxChatResponseFunctionCall[];
-    };
-}
-declare class AxGen<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxProgram<IN, OUT> {
-    private promptTemplate;
-    private asserts;
-    private streamingAsserts;
-    private options?;
-    private functions?;
-    private fieldProcessors;
-    private streamingFieldProcessors;
-    private excludeContentFromTrace;
-    private thoughtFieldName;
-    constructor(signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: Readonly<AxProgramForwardOptions>);
-    private getSignatureName;
-    private getMetricsInstruments;
-    updateMeter(meter?: Meter): void;
-    private createStates;
-    addAssert: (fn: AxAssertion["fn"], message?: string) => void;
-    addStreamingAssert: (fieldName: string, fn: AxStreamingAssertion["fn"], message?: string) => void;
-    private addFieldProcessorInternal;
-    addStreamingFieldProcessor: (fieldName: string, fn: AxFieldProcessor["process"]) => void;
-    addFieldProcessor: (fieldName: string, fn: AxFieldProcessor["process"]) => void;
-    private forwardSendRequest;
-    private forwardCore;
-    private _forward2;
-    _forward1(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options: Readonly<AxProgramForwardOptions>): AxGenStreamingOut<OUT>;
-    forward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
-    streamingForward(ai: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
-    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
-    private isDebug;
-    private getLogger;
-}
-type AxGenerateErrorDetails = {
-    model?: string;
-    maxTokens?: number;
-    streaming: boolean;
-    signature: {
-        input: Readonly<AxIField[]>;
-        output: Readonly<AxIField[]>;
-        description?: string;
-    };
-};
-type ErrorOptions = {
-    cause?: Error;
-};
-declare class AxGenerateError extends Error {
-    readonly details: AxGenerateErrorDetails;
-    constructor(message: string, details: Readonly<AxGenerateErrorDetails>, options?: ErrorOptions);
-}
-
-type AxFlowState = Record<string, unknown>;
-type AxFlowStepFunction = (state: AxFlowState, context: Readonly<{
-    mainAi: AxAIService;
-    mainOptions?: AxProgramForwardOptions;
-}>) => Promise<AxFlowState> | AxFlowState;
-interface AxFlowDynamicContext {
-    ai?: AxAIService;
-    options?: AxProgramForwardOptions;
-}
-type GetGenIn<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<infer IN, AxGenOut> ? IN : never;
-type GetGenOut<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<AxGenIn, infer OUT> ? OUT : never;
-type InferAxGen<TSig extends string> = TSig extends string ? AxGen<AxGenIn, AxGenOut> : never;
-type NodeResultKey<TNodeName extends string> = `${TNodeName}Result`;
-type AddNodeResult<TState extends AxFlowState, TNodeName extends string, TNodeOut extends AxGenOut> = TState & {
-    [K in NodeResultKey<TNodeName>]: TNodeOut;
-};
-type AxFlowTypedParallelBranch<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> = (subFlow: AxFlowTypedSubContext<TNodes, TState>) => AxFlowTypedSubContext<TNodes, AxFlowState>;
-interface AxFlowTypedSubContext<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> {
-    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
-    executeSteps(initialState: TState, context: Readonly<{
-        mainAi: AxAIService;
-        mainOptions?: AxProgramForwardOptions;
-    }>): Promise<AxFlowState>;
-}
-type AxFlowParallelBranch = (subFlow: AxFlowSubContext) => AxFlowSubContext;
-interface AxFlowSubContext {
-    execute(nodeName: string, mapping: (state: AxFlowState) => Record<string, AxFieldValue>, dynamicContext?: AxFlowDynamicContext): this;
-    map(transform: (state: AxFlowState) => AxFlowState): this;
-    executeSteps(initialState: AxFlowState, context: Readonly<{
-        mainAi: AxAIService;
-        mainOptions?: AxProgramForwardOptions;
-    }>): Promise<AxFlowState>;
-}
-interface AxFlowExecutionStep {
-    type: 'execute' | 'map' | 'other';
-    nodeName?: string;
-    dependencies: string[];
-    produces: string[];
-    stepFunction: AxFlowStepFunction;
-    stepIndex: number;
-}
-interface AxFlowParallelGroup {
-    level: number;
-    steps: AxFlowExecutionStep[];
-}
-/**
- * AxFlow - A fluent, chainable API for building and orchestrating complex, stateful AI programs.
- *
- * Now with advanced type-safe chaining where each method call evolves the type information,
- * providing compile-time type safety and superior IntelliSense.
- *
- * @example
- * ```typescript
- * const flow = new AxFlow<{ topic: string }, { finalAnswer: string }>()
- *   .node('summarizer', 'text:string -> summary:string')
- *   .node('critic', 'summary:string -> critique:string')
- *   .execute('summarizer', state => ({ text: `About ${state.topic}` })) // state is { topic: string }
- *   .execute('critic', state => ({ summary: state.summarizerResult.summary })) // state evolves!
- *   .map(state => ({ finalAnswer: state.criticResult.critique })) // fully typed!
- *
- * const result = await flow.forward(ai, { topic: "AI safety" })
- * ```
- */
-declare class AxFlow<IN extends AxGenIn, OUT extends AxGenOut, TNodes extends Record<string, AxGen<any, any>> = Record<string, never>, // Node registry for type tracking
-TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
-    private readonly nodes;
-    private readonly flowDefinition;
-    private readonly nodeGenerators;
-    private readonly loopStack;
-    private readonly stepLabels;
-    private branchContext;
-    private readonly autoParallelConfig;
-    private readonly executionPlanner;
-    constructor(signature?: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: {
-        autoParallel?: boolean;
-    });
-    /**
-     * Declares a reusable computational node using a signature string.
-     * Returns a new AxFlow type that tracks this node in the TNodes registry.
-     *
-     * @param name - The name of the node
-     * @param signature - Signature string in the same format as AxSignature
-     * @param options - Optional program forward options (same as AxGen)
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```typescript
-     * flow.node('summarizer', 'text:string -> summary:string')
-     * flow.node('analyzer', 'text:string -> analysis:string, confidence:number', { debug: true })
-     * ```
-     */
-    node<TName extends string, TSig extends string>(name: TName, signature: TSig, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: InferAxGen<TSig>;
-    }, // Add new node to registry
-    TState>;
-    /**
-     * Declares a reusable computational node using an AxSignature instance.
-     * This allows using pre-configured signatures in the flow.
-     *
-     * @param name - The name of the node
-     * @param signature - AxSignature instance to use for this node
-     * @param options - Optional program forward options (same as AxGen)
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```typescript
-     * const sig = new AxSignature('text:string -> summary:string')
-     * flow.node('summarizer', sig, { temperature: 0.1 })
-     * ```
-     */
-    node<TName extends string>(name: TName, signature: AxSignature, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: AxGen<AxGenIn, AxGenOut>;
-    }, // Add new node to registry
-    TState>;
-    /**
-     * Declares a reusable computational node using an existing AxGen instance.
-     * This allows reusing pre-configured generators in the flow.
-     *
-     * @param name - The name of the node
-     * @param axgenInstance - Existing AxGen instance to use for this node
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```typescript
-     * const summarizer = new AxGen('text:string -> summary:string', { temperature: 0.1 })
-     * flow.node('summarizer', summarizer)
-     * ```
-     */
-    node<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: TGen;
-    }, // Add new node to registry with exact type
-    TState>;
-    /**
-     * Declares a reusable computational node using a class that extends AxProgram.
-     * This allows using custom program classes in the flow.
-     *
-     * @param name - The name of the node
-     * @param programClass - Class that extends AxProgram to use for this node
-     * @returns New AxFlow instance with updated TNodes type
-     *
-     * @example
-     * ```typescript
-     * class CustomProgram extends AxProgram<{ input: string }, { output: string }> {
-     *   async forward(ai, values) { return { output: values.input.toUpperCase() } }
-     * }
-     * flow.node('custom', CustomProgram)
-     * ```
-     */
-    node<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: InstanceType<TProgram>;
-    }, // Add new node to registry with exact type
-    TState>;
-    /**
-     * Short alias for node() - supports signature strings, AxSignature instances, AxGen instances, and program classes
-     */
-    n<TName extends string, TSig extends string>(name: TName, signature: TSig, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: InferAxGen<TSig>;
-    }, TState>;
-    n<TName extends string>(name: TName, signature: AxSignature, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: AxGen<AxGenIn, AxGenOut>;
-    }, TState>;
-    n<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: TGen;
-    }, TState>;
-    n<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
-        [K in TName]: InstanceType<TProgram>;
-    }, TState>;
-    /**
-     * Applies a synchronous transformation to the state object.
-     * Returns a new AxFlow type with the evolved state.
-     *
-     * @param transform - Function that takes the current state and returns a new state
-     * @returns New AxFlow instance with updated TState type
-     *
-     * @example
-     * ```typescript
-     * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
-     * ```
-     */
-    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Short alias for map()
-     */
-    m<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
-    /**
-     * Labels a step for later reference (useful for feedback loops).
-     *
-     * @param label - The label to assign to the current step position
-     * @returns this (for chaining, no type change)
-     *
-     * @example
-     * ```typescript
-     * flow.label('retry-point')
-     *   .execute('queryGen', ...)
-     * ```
-     */
-    label(label: string): this;
-    /**
-     * Short alias for label()
-     */
-    l(label: string): this;
-    /**
-     * Executes a previously defined node with full type safety.
-     * The node name must exist in TNodes, and the mapping function is typed based on the node's signature.
-     *
-     * @param nodeName - The name of the node to execute (must exist in TNodes)
-     * @param mapping - Typed function that takes the current state and returns the input for the node
-     * @param dynamicContext - Optional object to override the AI service or options for this specific step
-     * @returns New AxFlow instance with TState augmented with the node's result
-     *
-     * @example
-     * ```typescript
-     * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
-     * ```
-     */
-    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    /**
-     * Short alias for execute()
-     */
-    e<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    /**
-     * Starts a conditional branch based on a predicate function.
-     *
-     * @param predicate - Function that takes state and returns a value to branch on
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.branch(state => state.qualityResult.needsMoreInfo)
-     *   .when(true)
-     *     .execute('queryGen', ...)
-     *   .when(false)
-     *     .execute('answer', ...)
-     *   .merge()
-     * ```
-     */
-    branch(predicate: (state: TState) => unknown): this;
-    /**
-     * Short alias for branch()
-     */
-    b(predicate: (state: TState) => unknown): this;
-    /**
-     * Defines a branch case for the current branch context.
-     *
-     * @param value - The value to match against the branch predicate result
-     * @returns this (for chaining)
-     */
-    when(value: unknown): this;
-    /**
-     * Short alias for when()
-     */
-    w(value: unknown): this;
-    /**
-     * Ends the current branch and merges all branch paths back into the main flow.
-     * Optionally specify the explicit merged state type for better type safety.
-     *
-     * @param explicitMergedType - Optional type hint for the merged state (defaults to current TState)
-     * @returns AxFlow instance with the merged state type
-     *
-     * @example
-     * ```typescript
-     * // Default behavior - preserves current TState
-     * flow.branch(state => state.type)
-     *   .when('simple').execute('simpleProcessor', ...)
-     *   .when('complex').execute('complexProcessor', ...)
-     *   .merge()
-     *
-     * // Explicit type - specify exact merged state shape
-     * flow.branch(state => state.type)
-     *   .when('simple').map(state => ({ result: state.simpleResult, method: 'simple' }))
-     *   .when('complex').map(state => ({ result: state.complexResult, method: 'complex' }))
-     *   .merge<{ result: string; method: string }>()
-     * ```
-     */
-    merge<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
-    /**
-     * Short alias for merge()
-     */
-    mg<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
-    /**
-     * Executes multiple operations in parallel and merges their results.
-     * Both typed and legacy untyped branches are supported.
-     *
-     * @param branches - Array of functions that define parallel operations
-     * @returns Object with merge method for combining results
-     *
-     * @example
-     * ```typescript
-     * flow.parallel([
-     *   subFlow => subFlow.execute('retrieve1', state => ({ query: state.query1 })),
-     *   subFlow => subFlow.execute('retrieve2', state => ({ query: state.query2 })),
-     *   subFlow => subFlow.execute('retrieve3', state => ({ query: state.query3 }))
-     * ]).merge('documents', (docs1, docs2, docs3) => [...docs1, ...docs2, ...docs3])
-     * ```
-     */
-    parallel(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
-        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
-            [K in TResultKey]: T;
-        }>;
-    };
-    /**
-     * Short alias for parallel()
-     */
-    p(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
-        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
-            [K in TResultKey]: T;
-        }>;
-    };
-    /**
-     * Creates a feedback loop that jumps back to a labeled step if a condition is met.
-     *
-     * @param condition - Function that returns true to trigger the feedback loop
-     * @param targetLabel - The label to jump back to
-     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 10)
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.label('retry-point')
-     *   .execute('answer', ...)
-     *   .execute('qualityCheck', ...)
-     *   .feedback(state => state.qualityCheckResult.confidence < 0.7, 'retry-point')
-     * ```
-     */
-    feedback(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
-    /**
-     * Short alias for feedback()
-     */
-    fb(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
-    /**
-     * Marks the beginning of a loop block.
-     *
-     * @param condition - Function that takes the current state and returns a boolean
-     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 100)
-     * @returns this (for chaining)
-     *
-     * @example
-     * ```typescript
-     * flow.while(state => state.iterations < 3, 10)
-     *   .map(state => ({ ...state, iterations: (state.iterations || 0) + 1 }))
-     *   .endWhile()
-     * ```
-     */
-    while(condition: (state: TState) => boolean, maxIterations?: number): this;
-    /**
-     * Short alias for while()
-     */
-    wh(condition: (state: TState) => boolean, maxIterations?: number): this;
-    /**
-     * Marks the end of a loop block.
-     *
-     * @returns this (for chaining)
-     */
-    endWhile(): this;
-    /**
-     * Short alias for endWhile()
-     */
-    end(): this;
-    /**
-     * Executes the flow with the given AI service and input values.
-     *
-     * @param ai - The AI service to use as the default for all steps
-     * @param values - The input values for the flow
-     * @param options - Optional forward options to use as defaults (includes autoParallel override)
-     * @returns Promise that resolves to the final output
-     */
-    forward(ai: Readonly<AxAIService>, values: IN, options?: Readonly<AxProgramForwardOptions & {
-        autoParallel?: boolean;
-    }>): Promise<OUT>;
-    /**
-     * Gets execution plan information for debugging automatic parallelization
-     *
-     * @returns Object with execution plan details
-     */
-    getExecutionPlan(): {
-        totalSteps: number;
-        parallelGroups: number;
-        maxParallelism: number;
-        autoParallelEnabled: boolean;
-        steps?: AxFlowExecutionStep[];
-        groups?: AxFlowParallelGroup[];
-    };
-}
-/**
- * Typed implementation of the sub-context for parallel execution with full type safety
- */
-declare class AxFlowTypedSubContextImpl<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> implements AxFlowTypedSubContext<TNodes, TState> {
-    private readonly nodeGenerators;
-    private readonly steps;
-    constructor(nodeGenerators: Map<string, AxGen<AxGenIn, AxGenOut> | AxProgram<AxGenIn, AxGenOut>>);
-    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
-    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
-    executeSteps(initialState: TState, context: Readonly<{
-        mainAi: AxAIService;
-        mainOptions?: AxProgramForwardOptions;
-    }>): Promise<AxFlowState>;
-}
-
-type AxDataRow = {
-    row: Record<string, AxFieldValue>;
-};
-declare class AxHFDataLoader {
-    private rows;
-    private baseUrl;
-    private dataset;
-    private split;
-    private config;
-    private options?;
-    constructor({ dataset, split, config, options, }: Readonly<{
-        dataset: string;
-        split: string;
-        config: string;
-        options?: Readonly<{
-            offset?: number;
-            length?: number;
-        }>;
+declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
+    private maxBootstrappedDemos;
+    private maxLabeledDemos;
+    private numCandidates;
+    private initTemperature;
+    private numTrials;
+    private minibatch;
+    private minibatchSize;
+    private minibatchFullEvalSteps;
+    private programAwareProposer;
+    private dataAwareProposer;
+    private viewDataBatchSize;
+    private tipAwareProposer;
+    private fewshotAwareProposer;
+    private earlyStoppingTrials;
+    private minImprovementThreshold;
+    private bayesianOptimization;
+    private acquisitionFunction;
+    private explorationWeight;
+    private sampleCount;
+    private miproConfigHistory;
+    private surrogateModel;
+    constructor(args: Readonly<AxOptimizerArgs & {
+        options?: AxMiPROOptimizerOptions;
     }>);
-    private fetchDataFromAPI;
-    loadData(): Promise<AxDataRow[]>;
-    setData(rows: AxDataRow[]): void;
-    getData(): AxDataRow[];
-    getRows<T>({ count, fields, renameMap, }: Readonly<{
-        count: number;
-        fields: readonly string[];
-        renameMap?: Record<string, string>;
-    }>): Promise<T[]>;
-}
-
-declare enum AxJSInterpreterPermission {
-    FS = "node:fs",
-    NET = "net",
-    OS = "os",
-    CRYPTO = "crypto",
-    PROCESS = "process"
-}
-declare class AxJSInterpreter {
-    private permissions;
-    constructor({ permissions, }?: Readonly<{
-        permissions?: readonly AxJSInterpreterPermission[];
-    }> | undefined);
-    private codeInterpreterJavascript;
-    toFunction(): AxFunction;
-}
-
-declare const axSpanAttributes: {
-    LLM_SYSTEM: string;
-    LLM_OPERATION_NAME: string;
-    LLM_REQUEST_MODEL: string;
-    LLM_REQUEST_MAX_TOKENS: string;
-    LLM_REQUEST_TEMPERATURE: string;
-    LLM_REQUEST_TOP_K: string;
-    LLM_REQUEST_FREQUENCY_PENALTY: string;
-    LLM_REQUEST_PRESENCE_PENALTY: string;
-    LLM_REQUEST_STOP_SEQUENCES: string;
-    LLM_REQUEST_LLM_IS_STREAMING: string;
-    LLM_REQUEST_TOP_P: string;
-    LLM_USAGE_INPUT_TOKENS: string;
-    LLM_USAGE_OUTPUT_TOKENS: string;
-    LLM_USAGE_TOTAL_TOKENS: string;
-    LLM_USAGE_THOUGHTS_TOKENS: string;
-    DB_SYSTEM: string;
-    DB_TABLE: string;
-    DB_NAMESPACE: string;
-    DB_ID: string;
-    DB_QUERY_TEXT: string;
-    DB_VECTOR: string;
-    DB_OPERATION_NAME: string;
-    DB_VECTOR_QUERY_TOP_K: string;
-    DB_QUERY_EMBEDDINGS: string;
-    DB_QUERY_RESULT: string;
-    DB_QUERY_EMBEDDINGS_VECTOR: string;
-    DB_QUERY_RESULT_ID: string;
-    DB_QUERY_RESULT_SCORE: string;
-    DB_QUERY_RESULT_DISTANCE: string;
-    DB_QUERY_RESULT_METADATA: string;
-    DB_QUERY_RESULT_VECTOR: string;
-    DB_QUERY_RESULT_DOCUMENT: string;
-};
-declare const axSpanEvents: {
-    GEN_AI_USER_MESSAGE: string;
-    GEN_AI_SYSTEM_MESSAGE: string;
-    GEN_AI_ASSISTANT_MESSAGE: string;
-    GEN_AI_TOOL_MESSAGE: string;
-    GEN_AI_CHOICE: string;
-    GEN_AI_USAGE: string;
-};
-declare enum AxLLMRequestTypeValues {
-    COMPLETION = "completion",
-    CHAT = "chat",
-    RERANK = "rerank",
-    UNKNOWN = "unknown"
-}
-declare enum AxSpanKindValues {
-    WORKFLOW = "workflow",
-    TASK = "task",
-    AGENT = "agent",
-    TOOL = "tool",
-    UNKNOWN = "unknown"
-}
-
-interface JSONRPCRequest<T> {
-    jsonrpc: '2.0';
-    id: string | number;
-    method: string;
-    params?: T;
-}
-interface JSONRPCSuccessResponse<T = unknown> {
-    jsonrpc: '2.0';
-    id: string | number;
-    result: T;
-}
-interface JSONRPCErrorResponse {
-    jsonrpc: '2.0';
-    id: string | number;
-    error: {
-        code: number;
-        message: string;
-        data?: unknown;
-    };
-}
-type JSONRPCResponse<T = unknown> = JSONRPCSuccessResponse<T> | JSONRPCErrorResponse;
-interface JSONRPCNotification {
-    jsonrpc: '2.0';
-    method: string;
-    params?: Record<string, unknown>;
-}
-
-interface AxMCPTransport {
     /**
-     * Sends a JSON-RPC request or notification and returns the response
-     * @param message The JSON-RPC request or notification to send
-     * @returns A Promise that resolves to the JSON-RPC response
+     * Configures the optimizer for light, medium, or heavy optimization
+     * @param level The optimization level: "light", "medium", or "heavy"
      */
-    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    configureAuto(level: 'light' | 'medium' | 'heavy'): void;
     /**
-     * Sends a JSON-RPC notification
-     * @param message The JSON-RPC notification to send
+     * Generates creative tips for instruction generation
      */
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    private generateTips;
     /**
-     * Connects to the transport if needed
-     * This method is optional and only required for transports that need connection setup
+     * Generates program summary for context-aware instruction generation
      */
-    connect?(): Promise<void>;
-}
-
-declare class AxMCPHTTPSSETransport implements AxMCPTransport {
-    private endpoint;
-    private sseUrl;
-    private eventSource?;
-    constructor(sseUrl: string);
-    connect(): Promise<void>;
-    send(message: JSONRPCRequest<unknown> | JSONRPCNotification): Promise<JSONRPCResponse<unknown>>;
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
-}
-interface AxMCPStreamableHTTPTransportOptions {
+    private generateProgramSummary;
     /**
-     * Custom headers to include with all HTTP requests
-     * Note: Content-Type, Accept, and Mcp-Session-Id are managed automatically
+     * Generates dataset summary for context-aware instruction generation
      */
-    headers?: Record<string, string>;
+    private generateDatasetSummary;
     /**
-     * Authorization header value (convenience for common use case)
-     * If provided, will be added to the headers as 'Authorization'
+     * Enhanced instruction generation using AI with program and data awareness
      */
-    authorization?: string;
-}
-/**
- * AxMCPStreambleHTTPTransport implements the 2025-03-26 Streamable HTTP transport specification
- * This transport uses a single HTTP endpoint that supports both POST and GET methods
- */
-declare class AxMCPStreambleHTTPTransport implements AxMCPTransport {
-    private mcpEndpoint;
-    private sessionId?;
-    private eventSource?;
-    private pendingRequests;
-    private messageHandler?;
-    private customHeaders;
-    constructor(mcpEndpoint: string, options?: AxMCPStreamableHTTPTransportOptions);
+    private generateInstruction;
     /**
-     * Update custom headers (useful for refreshing tokens)
+     * Generates instruction candidates using enhanced AI-powered generation
+     * @param options Optional compile options that may override teacher AI
+     * @returns Array of generated instruction candidates
      */
-    setHeaders(headers: Record<string, string>): void;
+    private proposeInstructionCandidates;
     /**
-     * Update authorization header (convenience method)
+     * Bootstraps few-shot examples for the program
      */
-    setAuthorization(authorization: string): void;
+    private bootstrapFewShotExamples;
     /**
-     * Get a copy of the current custom headers
+     * Selects labeled examples directly from the training set
      */
-    getHeaders(): Record<string, string>;
+    private selectLabeledExamples;
     /**
-     * Build headers for HTTP requests, merging custom headers with required ones
+     * Runs optimization to find the best combination of few-shot examples and instructions
      */
-    private buildHeaders;
+    private runOptimization;
+    private evaluateConfig;
     /**
-     * Set a handler for incoming server messages (requests/notifications)
+     * Fisher-Yates shuffle for stochastic evaluation
      */
-    setMessageHandler(handler: (message: JSONRPCRequest<unknown> | JSONRPCNotification) => void): void;
-    connect(): Promise<void>;
+    private shuffleArray;
+    private applyConfigToProgram;
     /**
-     * Opens an SSE stream to listen for server-initiated messages
+     * The main compile method to run MIPROv2 optimization
      */
-    openListeningStream(): Promise<void>;
+    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxMiPROResult<IN, OUT>>;
     /**
-     * Opens an SSE stream using fetch API to support custom headers
+     * Applies a configuration to an AxGen instance
      */
-    private openListeningStreamWithFetch;
-    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
-    private handleSSEResponse;
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    private applyConfigToAxGen;
     /**
-     * Explicitly terminate the session (if supported by server)
+     * Get optimizer-specific configuration
+     * @returns Current optimizer configuration
      */
-    terminateSession(): Promise<void>;
+    getConfiguration(): Record<string, unknown>;
     /**
-     * Close any open connections
+     * Update optimizer configuration
+     * @param config New configuration to merge with existing
      */
-    close(): void;
-}
-
-interface AxMiPROResult<IN extends AxGenIn, OUT extends AxGenOut> extends AxOptimizerResult<OUT> {
-    optimizedGen?: AxGen<IN, OUT>;
-}
-declare class AxMiPRO<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
-    private maxBootstrappedDemos;
-    private maxLabeledDemos;
-    private numCandidates;
-    private initTemperature;
-    private numTrials;
-    private minibatch;
-    private minibatchSize;
-    private minibatchFullEvalSteps;
-    private programAwareProposer;
-    private dataAwareProposer;
-    private viewDataBatchSize;
-    private tipAwareProposer;
-    private fewshotAwareProposer;
-    private earlyStoppingTrials;
-    private minImprovementThreshold;
-    private bayesianOptimization;
-    private acquisitionFunction;
-    private explorationWeight;
-    private sampleCount;
-    private miproConfigHistory;
-    private surrogateModel;
-    constructor(args: Readonly<AxOptimizerArgs & {
-        options?: AxMiPROOptimizerOptions;
-    }>);
+    updateConfiguration(config: Readonly<Record<string, unknown>>): void;
+    /**
+     * Reset optimizer state for reuse with different programs
+     */
+    reset(): void;
+    /**
+     * Validate that the optimizer can handle the given program
+     * @param program Program to validate
+     * @returns Validation result with any issues found
+     */
+    validateProgram(program: Readonly<AxProgram<IN, OUT>>): {
+        isValid: boolean;
+        issues: string[];
+        suggestions: string[];
+    };
+    /**
+     * Encodes a configuration into a string key for surrogate model lookup
+     */
+    private encodeConfiguration;
+    /**
+     * Updates the surrogate model with a new configuration-score pair
+     */
+    private updateSurrogateModel;
     /**
-     * Configures the optimizer for light, medium, or heavy optimization
-     * @param level The optimization level: "light", "medium", or "heavy"
+     * Predicts performance using the surrogate model
      */
-    configureAuto(level: 'light' | 'medium' | 'heavy'): void;
+    private predictPerformance;
     /**
-     * Generates creative tips for instruction generation
+     * Calculates acquisition function value for Bayesian optimization
      */
-    private generateTips;
+    private calculateAcquisitionValue;
     /**
-     * Generates program summary for context-aware instruction generation
+     * Error function approximation for acquisition function calculations
      */
-    private generateProgramSummary;
+    private erf;
     /**
-     * Generates dataset summary for context-aware instruction generation
+     * Selects the next configuration to evaluate using Bayesian optimization
      */
-    private generateDatasetSummary;
+    private selectConfigurationViaBayesianOptimization;
+}
+
+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> {
+    private reg;
+    constructor();
+    register(instance: AxInstanceRegistryItem<T, IN, OUT>): void;
+    [Symbol.iterator](): Generator<AxInstanceRegistryItem<T, IN, OUT>, void, unknown>;
+}
+
+interface AxSamplePickerOptions<OUT extends AxGenOut> {
+    resultPicker?: AxResultPickerFunction<OUT>;
+}
+
+declare const AxStringUtil: {
+    trimNonAlphaNum: (str: string) => string;
+    splitIntoTwo: (str: string, separator: Readonly<RegExp | string>) => string[];
+    dedup: (seq: readonly string[]) => string[];
+    extractIdAndText: (input: string) => {
+        id: number;
+        text: string;
+    };
+    extractIndexPrefixedText: (input: string) => string;
+    batchArray: <T>(arr: readonly T[], size: number) => T[][];
+};
+
+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;
+    };
+};
+
+type AxFlowState = Record<string, unknown>;
+type AxFlowStepFunction = (state: AxFlowState, context: Readonly<{
+    mainAi: AxAIService;
+    mainOptions?: AxProgramForwardOptions;
+}>) => Promise<AxFlowState> | AxFlowState;
+interface AxFlowDynamicContext {
+    ai?: AxAIService;
+    options?: AxProgramForwardOptions;
+}
+type GetGenIn<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<infer IN, AxGenOut> ? IN : never;
+type GetGenOut<T extends AxGen<AxGenIn, AxGenOut>> = T extends AxGen<AxGenIn, infer OUT> ? OUT : never;
+type InferAxGen<TSig extends string> = TSig extends string ? AxGen<AxGenIn, AxGenOut> : never;
+type NodeResultKey<TNodeName extends string> = `${TNodeName}Result`;
+type AddNodeResult<TState extends AxFlowState, TNodeName extends string, TNodeOut extends AxGenOut> = TState & {
+    [K in NodeResultKey<TNodeName>]: TNodeOut;
+};
+type AxFlowTypedParallelBranch<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> = (subFlow: AxFlowTypedSubContext<TNodes, TState>) => AxFlowTypedSubContext<TNodes, AxFlowState>;
+interface AxFlowTypedSubContext<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> {
+    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
+    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
+    executeSteps(initialState: TState, context: Readonly<{
+        mainAi: AxAIService;
+        mainOptions?: AxProgramForwardOptions;
+    }>): Promise<AxFlowState>;
+}
+type AxFlowParallelBranch = (subFlow: AxFlowSubContext) => AxFlowSubContext;
+interface AxFlowSubContext {
+    execute(nodeName: string, mapping: (state: AxFlowState) => Record<string, AxFieldValue>, dynamicContext?: AxFlowDynamicContext): this;
+    map(transform: (state: AxFlowState) => AxFlowState): this;
+    executeSteps(initialState: AxFlowState, context: Readonly<{
+        mainAi: AxAIService;
+        mainOptions?: AxProgramForwardOptions;
+    }>): Promise<AxFlowState>;
+}
+interface AxFlowExecutionStep {
+    type: 'execute' | 'map' | 'other';
+    nodeName?: string;
+    dependencies: string[];
+    produces: string[];
+    stepFunction: AxFlowStepFunction;
+    stepIndex: number;
+}
+interface AxFlowParallelGroup {
+    level: number;
+    steps: AxFlowExecutionStep[];
+}
+/**
+ * AxFlow - A fluent, chainable API for building and orchestrating complex, stateful AI programs.
+ *
+ * Now with advanced type-safe chaining where each method call evolves the type information,
+ * providing compile-time type safety and superior IntelliSense.
+ *
+ * @example
+ * ```typescript
+ * const flow = new AxFlow<{ topic: string }, { finalAnswer: string }>()
+ *   .node('summarizer', 'text:string -> summary:string')
+ *   .node('critic', 'summary:string -> critique:string')
+ *   .execute('summarizer', state => ({ text: `About ${state.topic}` })) // state is { topic: string }
+ *   .execute('critic', state => ({ summary: state.summarizerResult.summary })) // state evolves!
+ *   .map(state => ({ finalAnswer: state.criticResult.critique })) // fully typed!
+ *
+ * const result = await flow.forward(ai, { topic: "AI safety" })
+ * ```
+ */
+declare class AxFlow<IN extends AxGenIn, OUT extends AxGenOut, TNodes extends Record<string, AxGen<any, any>> = Record<string, never>, // Node registry for type tracking
+TState extends AxFlowState = IN> extends AxProgram<IN, OUT> {
+    private readonly nodes;
+    private readonly flowDefinition;
+    private readonly nodeGenerators;
+    private readonly loopStack;
+    private readonly stepLabels;
+    private branchContext;
+    private readonly autoParallelConfig;
+    private readonly executionPlanner;
+    constructor(signature?: NonNullable<ConstructorParameters<typeof AxSignature>[0]>, options?: {
+        autoParallel?: boolean;
+    });
     /**
-     * Enhanced instruction generation using AI with program and data awareness
+     * Declares a reusable computational node using a signature string.
+     * Returns a new AxFlow type that tracks this node in the TNodes registry.
+     *
+     * @param name - The name of the node
+     * @param signature - Signature string in the same format as AxSignature
+     * @param options - Optional program forward options (same as AxGen)
+     * @returns New AxFlow instance with updated TNodes type
+     *
+     * @example
+     * ```typescript
+     * flow.node('summarizer', 'text:string -> summary:string')
+     * flow.node('analyzer', 'text:string -> analysis:string, confidence:number', { debug: true })
+     * ```
      */
-    private generateInstruction;
+    node<TName extends string, TSig extends string>(name: TName, signature: TSig, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: InferAxGen<TSig>;
+    }, // Add new node to registry
+    TState>;
     /**
-     * Generates instruction candidates using enhanced AI-powered generation
-     * @param options Optional compile options that may override teacher AI
-     * @returns Array of generated instruction candidates
+     * Declares a reusable computational node using an AxSignature instance.
+     * This allows using pre-configured signatures in the flow.
+     *
+     * @param name - The name of the node
+     * @param signature - AxSignature instance to use for this node
+     * @param options - Optional program forward options (same as AxGen)
+     * @returns New AxFlow instance with updated TNodes type
+     *
+     * @example
+     * ```typescript
+     * const sig = new AxSignature('text:string -> summary:string')
+     * flow.node('summarizer', sig, { temperature: 0.1 })
+     * ```
      */
-    private proposeInstructionCandidates;
+    node<TName extends string>(name: TName, signature: AxSignature, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: AxGen<AxGenIn, AxGenOut>;
+    }, // Add new node to registry
+    TState>;
     /**
-     * Bootstraps few-shot examples for the program
+     * Declares a reusable computational node using an existing AxGen instance.
+     * This allows reusing pre-configured generators in the flow.
+     *
+     * @param name - The name of the node
+     * @param axgenInstance - Existing AxGen instance to use for this node
+     * @returns New AxFlow instance with updated TNodes type
+     *
+     * @example
+     * ```typescript
+     * const summarizer = new AxGen('text:string -> summary:string', { temperature: 0.1 })
+     * flow.node('summarizer', summarizer)
+     * ```
      */
-    private bootstrapFewShotExamples;
+    node<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: TGen;
+    }, // Add new node to registry with exact type
+    TState>;
     /**
-     * Selects labeled examples directly from the training set
+     * Declares a reusable computational node using a class that extends AxProgram.
+     * This allows using custom program classes in the flow.
+     *
+     * @param name - The name of the node
+     * @param programClass - Class that extends AxProgram to use for this node
+     * @returns New AxFlow instance with updated TNodes type
+     *
+     * @example
+     * ```typescript
+     * class CustomProgram extends AxProgram<{ input: string }, { output: string }> {
+     *   async forward(ai, values) { return { output: values.input.toUpperCase() } }
+     * }
+     * flow.node('custom', CustomProgram)
+     * ```
      */
-    private selectLabeledExamples;
+    node<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: InstanceType<TProgram>;
+    }, // Add new node to registry with exact type
+    TState>;
     /**
-     * Runs optimization to find the best combination of few-shot examples and instructions
+     * Short alias for node() - supports signature strings, AxSignature instances, AxGen instances, and program classes
      */
-    private runOptimization;
-    private evaluateConfig;
+    n<TName extends string, TSig extends string>(name: TName, signature: TSig, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: InferAxGen<TSig>;
+    }, TState>;
+    n<TName extends string>(name: TName, signature: AxSignature, options?: Readonly<AxProgramForwardOptions>): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: AxGen<AxGenIn, AxGenOut>;
+    }, TState>;
+    n<TName extends string, TGen extends AxGen<any, any>>(name: TName, axgenInstance: TGen): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: TGen;
+    }, TState>;
+    n<TName extends string, TProgram extends new () => AxProgram<any, any>>(name: TName, programClass: TProgram): AxFlow<IN, OUT, TNodes & {
+        [K in TName]: InstanceType<TProgram>;
+    }, TState>;
     /**
-     * Fisher-Yates shuffle for stochastic evaluation
+     * Applies a synchronous transformation to the state object.
+     * Returns a new AxFlow type with the evolved state.
+     *
+     * @param transform - Function that takes the current state and returns a new state
+     * @returns New AxFlow instance with updated TState type
+     *
+     * @example
+     * ```typescript
+     * flow.map(state => ({ ...state, processedText: state.text.toLowerCase() }))
+     * ```
      */
-    private shuffleArray;
-    private applyConfigToProgram;
+    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
     /**
-     * The main compile method to run MIPROv2 optimization
+     * Short alias for map()
      */
-    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxCompileOptions): Promise<AxMiPROResult<IN, OUT>>;
+    m<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlow<IN, OUT, TNodes, TNewState>;
     /**
-     * Applies a configuration to an AxGen instance
+     * Labels a step for later reference (useful for feedback loops).
+     *
+     * @param label - The label to assign to the current step position
+     * @returns this (for chaining, no type change)
+     *
+     * @example
+     * ```typescript
+     * flow.label('retry-point')
+     *   .execute('queryGen', ...)
+     * ```
      */
-    private applyConfigToAxGen;
+    label(label: string): this;
     /**
-     * Get optimizer-specific configuration
-     * @returns Current optimizer configuration
+     * Short alias for label()
      */
-    getConfiguration(): Record<string, unknown>;
+    l(label: string): this;
     /**
-     * Update optimizer configuration
-     * @param config New configuration to merge with existing
+     * Executes a previously defined node with full type safety.
+     * The node name must exist in TNodes, and the mapping function is typed based on the node's signature.
+     *
+     * @param nodeName - The name of the node to execute (must exist in TNodes)
+     * @param mapping - Typed function that takes the current state and returns the input for the node
+     * @param dynamicContext - Optional object to override the AI service or options for this specific step
+     * @returns New AxFlow instance with TState augmented with the node's result
+     *
+     * @example
+     * ```typescript
+     * flow.execute('summarizer', state => ({ text: state.originalText }), { ai: cheapAI })
+     * ```
      */
-    updateConfiguration(config: Readonly<Record<string, unknown>>): void;
+    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     /**
-     * Reset optimizer state for reuse with different programs
+     * Short alias for execute()
      */
-    reset(): void;
+    e<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlow<IN, OUT, TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
     /**
-     * Validate that the optimizer can handle the given program
-     * @param program Program to validate
-     * @returns Validation result with any issues found
+     * Starts a conditional branch based on a predicate function.
+     *
+     * @param predicate - Function that takes state and returns a value to branch on
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * flow.branch(state => state.qualityResult.needsMoreInfo)
+     *   .when(true)
+     *     .execute('queryGen', ...)
+     *   .when(false)
+     *     .execute('answer', ...)
+     *   .merge()
+     * ```
      */
-    validateProgram(program: Readonly<AxProgram<IN, OUT>>): {
-        isValid: boolean;
-        issues: string[];
-        suggestions: string[];
-    };
+    branch(predicate: (state: TState) => unknown): this;
     /**
-     * Encodes a configuration into a string key for surrogate model lookup
+     * Short alias for branch()
      */
-    private encodeConfiguration;
+    b(predicate: (state: TState) => unknown): this;
     /**
-     * Updates the surrogate model with a new configuration-score pair
+     * Defines a branch case for the current branch context.
+     *
+     * @param value - The value to match against the branch predicate result
+     * @returns this (for chaining)
      */
-    private updateSurrogateModel;
+    when(value: unknown): this;
     /**
-     * Predicts performance using the surrogate model
+     * Short alias for when()
      */
-    private predictPerformance;
+    w(value: unknown): this;
     /**
-     * Calculates acquisition function value for Bayesian optimization
+     * Ends the current branch and merges all branch paths back into the main flow.
+     * Optionally specify the explicit merged state type for better type safety.
+     *
+     * @param explicitMergedType - Optional type hint for the merged state (defaults to current TState)
+     * @returns AxFlow instance with the merged state type
+     *
+     * @example
+     * ```typescript
+     * // Default behavior - preserves current TState
+     * flow.branch(state => state.type)
+     *   .when('simple').execute('simpleProcessor', ...)
+     *   .when('complex').execute('complexProcessor', ...)
+     *   .merge()
+     *
+     * // Explicit type - specify exact merged state shape
+     * flow.branch(state => state.type)
+     *   .when('simple').map(state => ({ result: state.simpleResult, method: 'simple' }))
+     *   .when('complex').map(state => ({ result: state.complexResult, method: 'complex' }))
+     *   .merge<{ result: string; method: string }>()
+     * ```
      */
-    private calculateAcquisitionValue;
+    merge<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
     /**
-     * Error function approximation for acquisition function calculations
+     * Short alias for merge()
      */
-    private erf;
+    mg<TMergedState extends AxFlowState = TState>(): AxFlow<IN, OUT, TNodes, TMergedState>;
     /**
-     * Selects the next configuration to evaluate using Bayesian optimization
-     */
-    private selectConfigurationViaBayesianOptimization;
-}
-
-type AxMockAIServiceConfig = {
-    name?: string;
-    id?: string;
-    modelInfo?: Partial<AxModelInfoWithProvider>;
-    embedModelInfo?: AxModelInfoWithProvider;
-    features?: {
-        functions?: boolean;
-        streaming?: boolean;
-    };
-    models?: AxAIModelList;
-    options?: AxAIServiceOptions;
-    chatResponse?: AxChatResponse | ReadableStream<AxChatResponse> | (() => Promise<AxChatResponse | ReadableStream<AxChatResponse>>) | ((req: Readonly<AxChatRequest<unknown>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<unknown, unknown>>) => Promise<AxChatResponse | ReadableStream<AxChatResponse>>);
-    embedResponse?: AxEmbedResponse | ((req: Readonly<AxEmbedRequest>) => AxEmbedResponse | Promise<AxEmbedResponse>);
-    shouldError?: boolean;
-    errorMessage?: string;
-    latencyMs?: number;
-};
-declare class AxMockAIService implements AxAIService {
-    private readonly config;
-    private metrics;
-    constructor(config?: AxMockAIServiceConfig);
-    getLastUsedChatModel(): unknown;
-    getLastUsedEmbedModel(): unknown;
-    getLastUsedModelConfig(): AxModelConfig | undefined;
-    getName(): string;
-    getId(): string;
-    getFeatures(_model?: string): {
-        functions: boolean;
-        streaming: boolean;
-    };
-    getModelList(): AxAIModelList | undefined;
-    getMetrics(): AxAIServiceMetrics;
-    chat(req: Readonly<AxChatRequest<unknown>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<unknown, unknown>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
-    embed(req: Readonly<AxEmbedRequest>, _options?: Readonly<AxAIServiceActionOptions>): Promise<AxEmbedResponse>;
-    setOptions(options: Readonly<AxAIServiceOptions>): void;
-    getOptions(): Readonly<AxAIServiceOptions>;
-    getLogger(): AxLoggerFunction;
-    private updateMetrics;
-}
-
-interface AxRateLimiterTokenUsageOptions {
-    debug?: boolean;
-}
-declare class AxRateLimiterTokenUsage {
-    private options?;
-    private maxTokens;
-    private refillRate;
-    private currentTokens;
-    private lastRefillTime;
-    constructor(maxTokens: number, refillRate: number, options?: Readonly<AxRateLimiterTokenUsageOptions>);
-    private refillTokens;
-    private waitUntilTokensAvailable;
-    acquire(tokens: number): Promise<void>;
-}
-
-interface AxSimpleClassifierForwardOptions {
-    cutoff?: number;
-    abortSignal?: AbortSignal;
-}
-declare class AxSimpleClassifierClass {
-    private readonly name;
-    private readonly context;
-    constructor(name: string, context: readonly string[]);
-    getName(): string;
-    getContext(): readonly string[];
-}
-declare class AxSimpleClassifier {
-    private readonly ai;
-    private db;
-    private debug?;
-    constructor(ai: AxAIService);
-    getState(): AxDBState | undefined;
-    setState(state: AxDBState): void;
-    setClasses: (classes: readonly AxSimpleClassifierClass[], options?: Readonly<{
-        abortSignal?: AbortSignal;
-    }>) => Promise<void>;
-    forward(text: string, options?: Readonly<AxSimpleClassifierForwardOptions>): Promise<string>;
-    setOptions(options: Readonly<{
-        debug?: boolean;
-    }>): void;
-}
-
-type AxEvaluateArgs<IN extends AxGenIn, OUT extends AxGenOut> = {
-    ai: AxAIService;
-    program: Readonly<AxProgram<IN, OUT>>;
-    examples: Readonly<AxExample[]>;
-};
-declare class AxTestPrompt<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> {
-    private ai;
-    private program;
-    private examples;
-    constructor({ ai, program, examples, }: Readonly<AxEvaluateArgs<IN, OUT>>);
-    run(metricFn: AxMetricFn): Promise<void>;
-}
-
-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;
+     * Executes multiple operations in parallel and merges their results.
+     * Both typed and legacy untyped branches are supported.
+     *
+     * @param branches - Array of functions that define parallel operations
+     * @returns Object with merge method for combining results
+     *
+     * @example
+     * ```typescript
+     * flow.parallel([
+     *   subFlow => subFlow.execute('retrieve1', state => ({ query: state.query1 })),
+     *   subFlow => subFlow.execute('retrieve2', state => ({ query: state.query2 })),
+     *   subFlow => subFlow.execute('retrieve3', state => ({ query: state.query3 }))
+     * ]).merge('documents', (docs1, docs2, docs3) => [...docs1, ...docs2, ...docs3])
+     * ```
+     */
+    parallel(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
+        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
+            [K in TResultKey]: T;
+        }>;
     };
-    optional: <T extends AxFieldType>(baseType: T) => T & {
-        readonly isOptional: true;
+    /**
+     * Short alias for parallel()
+     */
+    p(branches: (AxFlowParallelBranch | AxFlowTypedParallelBranch<TNodes, TState>)[]): {
+        merge<T, TResultKey extends string>(resultKey: TResultKey, mergeFunction: (...results: unknown[]) => T): AxFlow<IN, OUT, TNodes, TState & {
+            [K in TResultKey]: T;
+        }>;
     };
-    internal: <T extends AxFieldType>(baseType: T) => T & {
-        readonly isInternal: true;
+    /**
+     * Creates a feedback loop that jumps back to a labeled step if a condition is met.
+     *
+     * @param condition - Function that returns true to trigger the feedback loop
+     * @param targetLabel - The label to jump back to
+     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 10)
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * flow.label('retry-point')
+     *   .execute('answer', ...)
+     *   .execute('qualityCheck', ...)
+     *   .feedback(state => state.qualityCheckResult.confidence < 0.7, 'retry-point')
+     * ```
+     */
+    feedback(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
+    /**
+     * Short alias for feedback()
+     */
+    fb(condition: (state: TState) => boolean, targetLabel: string, maxIterations?: number): this;
+    /**
+     * Marks the beginning of a loop block.
+     *
+     * @param condition - Function that takes the current state and returns a boolean
+     * @param maxIterations - Maximum number of iterations to prevent infinite loops (default: 100)
+     * @returns this (for chaining)
+     *
+     * @example
+     * ```typescript
+     * flow.while(state => state.iterations < 3, 10)
+     *   .map(state => ({ ...state, iterations: (state.iterations || 0) + 1 }))
+     *   .endWhile()
+     * ```
+     */
+    while(condition: (state: TState) => boolean, maxIterations?: number): this;
+    /**
+     * Short alias for while()
+     */
+    wh(condition: (state: TState) => boolean, maxIterations?: number): this;
+    /**
+     * Marks the end of a loop block.
+     *
+     * @returns this (for chaining)
+     */
+    endWhile(): this;
+    /**
+     * Short alias for endWhile()
+     */
+    end(): this;
+    /**
+     * Executes the flow with the given AI service and input values.
+     *
+     * @param ai - The AI service to use as the default for all steps
+     * @param values - The input values for the flow
+     * @param options - Optional forward options to use as defaults (includes autoParallel override)
+     * @returns Promise that resolves to the final output
+     */
+    forward(ai: Readonly<AxAIService>, values: IN, options?: Readonly<AxProgramForwardOptions & {
+        autoParallel?: boolean;
+    }>): Promise<OUT>;
+    /**
+     * Gets execution plan information for debugging automatic parallelization
+     *
+     * @returns Object with execution plan details
+     */
+    getExecutionPlan(): {
+        totalSteps: number;
+        parallelGroups: number;
+        maxParallelism: number;
+        autoParallelEnabled: boolean;
+        steps?: AxFlowExecutionStep[];
+        groups?: AxFlowParallelGroup[];
     };
-};
-
-interface AxMetricsConfig {
-    enabled: boolean;
-    enabledCategories: ('generation' | 'streaming' | 'functions' | 'errors' | 'performance')[];
-    maxLabelLength: number;
-    samplingRate: number;
-}
-declare const axDefaultMetricsConfig: AxMetricsConfig;
-type AxErrorCategory = 'validation_error' | 'assertion_error' | 'timeout_error' | 'abort_error' | 'network_error' | 'auth_error' | 'rate_limit_error' | 'function_error' | 'parsing_error' | 'unknown_error';
-interface AxGenMetricsInstruments {
-    generationLatencyHistogram?: Histogram;
-    generationRequestsCounter?: Counter;
-    generationErrorsCounter?: Counter;
-    multiStepGenerationsCounter?: Counter;
-    stepsPerGenerationHistogram?: Histogram;
-    maxStepsReachedCounter?: Counter;
-    validationErrorsCounter?: Counter;
-    assertionErrorsCounter?: Counter;
-    errorCorrectionAttemptsHistogram?: Histogram;
-    errorCorrectionSuccessCounter?: Counter;
-    errorCorrectionFailureCounter?: Counter;
-    maxRetriesReachedCounter?: Counter;
-    functionsEnabledGenerationsCounter?: Counter;
-    functionCallStepsCounter?: Counter;
-    functionsExecutedPerGenerationHistogram?: Histogram;
-    functionErrorCorrectionCounter?: Counter;
-    fieldProcessorsExecutedCounter?: Counter;
-    streamingFieldProcessorsExecutedCounter?: Counter;
-    streamingGenerationsCounter?: Counter;
-    streamingDeltasEmittedCounter?: Counter;
-    streamingFinalizationLatencyHistogram?: Histogram;
-    samplesGeneratedHistogram?: Histogram;
-    resultPickerUsageCounter?: Counter;
-    resultPickerLatencyHistogram?: Histogram;
-    inputFieldsGauge?: Gauge;
-    outputFieldsGauge?: Gauge;
-    examplesUsedGauge?: Gauge;
-    demosUsedGauge?: Gauge;
-    promptRenderLatencyHistogram?: Histogram;
-    extractionLatencyHistogram?: Histogram;
-    assertionLatencyHistogram?: Histogram;
-    stateCreationLatencyHistogram?: Histogram;
-    memoryUpdateLatencyHistogram?: Histogram;
 }
-declare const axCheckMetricsHealth: () => {
-    healthy: boolean;
-    issues: string[];
-};
-declare const axUpdateMetricsConfig: (config: Readonly<Partial<AxMetricsConfig>>) => void;
-declare const axGetMetricsConfig: () => AxMetricsConfig;
-
-declare const axCreateDefaultLogger: (output?: (message: string) => void) => AxLoggerFunction;
-declare const axCreateDefaultTextLogger: (output?: (message: string) => void) => AxLoggerFunction;
-/**
- * Factory function to create an enhanced optimizer logger with clean visual formatting
- * that works for all optimizer types using semantic tags for proper categorization
- */
-declare const axCreateOptimizerLogger: (output?: (message: string) => void) => AxLoggerFunction;
-/**
- * Default optimizer logger instance
- */
-declare const axDefaultOptimizerLogger: AxLoggerFunction;
-
 /**
- * OpenAI: Model information
- */
-declare const axModelInfoOpenAI: AxModelInfo[];
-/**
- * OpenAI: Model information
- */
-declare const axModelInfoOpenAIResponses: AxModelInfo[];
-
-type AxChatRequestMessage = AxChatRequest['chatPrompt'][number];
-/**
- * Validates a chat request message item to ensure it meets the required criteria
- * @param item - The chat request message to validate
- * @throws {Error} When validation fails with a descriptive error message
- */
-declare function axValidateChatRequestMessage(item: AxChatRequestMessage): void;
-/**
- * Validates a chat response result to ensure it meets the required criteria
- * @param results - The chat response results to validate (single result or array)
- * @throws {Error} When validation fails with a descriptive error message
+ * Typed implementation of the sub-context for parallel execution with full type safety
  */
-declare function axValidateChatResponseResult(results: Readonly<AxChatResponseResult[]> | Readonly<AxChatResponseResult>): void;
-
-declare class AxAIOpenAIResponsesImpl<TModel, TEmbedModel, // Kept for interface compatibility, but not used by this impl.
-TResponsesReq extends AxAIOpenAIResponsesRequest<TModel>> implements AxAIServiceImpl<TModel, TEmbedModel, Readonly<AxAIOpenAIResponsesRequest<TModel>>, // ChatReq (now ResponsesReq)
-Readonly<AxAIOpenAIEmbedRequest<TEmbedModel>>, // EmbedReq
-Readonly<AxAIOpenAIResponsesResponse>, // ChatResp (now ResponsesResp)
-Readonly<AxAIOpenAIResponsesResponseDelta>, // ChatRespDelta (now ResponsesRespDelta)
-Readonly<AxAIOpenAIEmbedResponse>> {
-    private readonly config;
-    private readonly streamingUsage;
-    private readonly responsesReqUpdater?;
-    private tokensUsed;
-    constructor(config: Readonly<AxAIOpenAIResponsesConfig<TModel, TEmbedModel>>, streamingUsage: boolean, // If /v1/responses supports include_usage for streams
-    responsesReqUpdater?: ResponsesReqUpdater<TModel, TResponsesReq> | undefined);
-    getTokenUsage(): Readonly<AxTokenUsage> | undefined;
-    getModelConfig(): Readonly<AxModelConfig>;
-    private mapInternalContentToResponsesInput;
-    private createResponsesReqInternalInput;
-    createChatReq(req: Readonly<AxInternalChatRequest<TModel>>, config: Readonly<AxAIPromptConfig>): [Readonly<AxAPI>, Readonly<AxAIOpenAIResponsesRequest<TModel>>];
-    createChatResp(resp: Readonly<AxAIOpenAIResponsesResponse>): Readonly<AxChatResponse>;
-    createChatStreamResp(streamEvent: Readonly<AxAIOpenAIResponsesResponseDelta>): Readonly<AxChatResponse>;
-    createEmbedReq(req: Readonly<AxInternalEmbedRequest<TEmbedModel>>): [AxAPI, AxAIOpenAIEmbedRequest<TEmbedModel>];
-}
-
-declare class AxBootstrapFewShot<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxBaseOptimizer<IN, OUT> {
-    private maxRounds;
-    private maxDemos;
-    private maxExamples;
-    private batchSize;
-    private earlyStoppingPatience;
-    private costMonitoring;
-    private maxTokensPerGeneration;
-    private verboseMode;
-    private debugMode;
-    private traces;
-    constructor(args: Readonly<AxOptimizerArgs & {
-        options?: AxBootstrapOptimizerOptions;
-    }>);
-    private compileRound;
-    compile(program: Readonly<AxProgram<IN, OUT>>, metricFn: AxMetricFn, options?: AxBootstrapCompileOptions): Promise<AxOptimizerResult<OUT>>;
+declare class AxFlowTypedSubContextImpl<TNodes extends Record<string, AxGen<any, any>>, TState extends AxFlowState> implements AxFlowTypedSubContext<TNodes, TState> {
+    private readonly nodeGenerators;
+    private readonly steps;
+    constructor(nodeGenerators: Map<string, AxGen<AxGenIn, AxGenOut> | AxProgram<AxGenIn, AxGenOut>>);
+    execute<TNodeName extends keyof TNodes & string>(nodeName: TNodeName, mapping: (state: TState) => GetGenIn<TNodes[TNodeName]>, dynamicContext?: AxFlowDynamicContext): AxFlowTypedSubContext<TNodes, AddNodeResult<TState, TNodeName, GetGenOut<TNodes[TNodeName]>>>;
+    map<TNewState extends AxFlowState>(transform: (state: TState) => TNewState): AxFlowTypedSubContext<TNodes, TNewState>;
+    executeSteps(initialState: TState, context: Readonly<{
+        mainAi: AxAIService;
+        mainOptions?: AxProgramForwardOptions;
+    }>): Promise<AxFlowState>;
 }
 
-declare class AxChainOfThought<IN extends AxGenIn = AxGenIn, OUT extends AxGenOut = AxGenOut> extends AxGen<IN, OUT> {
-    constructor(signature: Readonly<AxSignature | string>, options?: Readonly<AxProgramForwardOptions & {
-        setVisibleReasoning?: boolean;
-    }>);
+interface AxDockerContainer {
+    Id: string;
+    Names: string[];
+    Image: string;
+    ImageID: string;
+    Command: string;
+    Created: number;
+    State: {
+        Status: string;
+        Running: boolean;
+        Paused: boolean;
+        Restarting: boolean;
+        OOMKilled: boolean;
+        Dead: boolean;
+        Pid: number;
+        ExitCode: number;
+        Error: string;
+        StartedAt: Date;
+        FinishedAt: Date;
+    };
+    Status: string;
+    Ports: Array<{
+        IP: string;
+        PrivatePort: number;
+        PublicPort: number;
+        Type: string;
+    }>;
+    Labels: {
+        [key: string]: string;
+    };
+    SizeRw: number;
+    SizeRootFs: number;
+    HostConfig: {
+        NetworkMode: string;
+    };
+    NetworkSettings: {
+        Networks: {
+            [key: string]: {
+                IPAddress: string;
+                IPPrefixLen: number;
+                Gateway: string;
+                MacAddress: string;
+            };
+        };
+    };
+    Mounts: Array<{
+        Type: string;
+        Source: string;
+        Destination: string;
+        Mode: string;
+        RW: boolean;
+        Propagation: string;
+    }>;
 }
-
-declare class AxDefaultResultReranker extends AxGen<AxRerankerIn, AxRerankerOut> {
-    constructor(options?: Readonly<AxProgramForwardOptions>);
-    forward: (ai: Readonly<AxAIService>, input: Readonly<AxRerankerIn>, options?: Readonly<AxProgramForwardOptions>) => Promise<AxRerankerOut>;
+declare class AxDockerSession {
+    private readonly apiUrl;
+    private containerId;
+    constructor(apiUrl?: string);
+    pullImage(imageName: string): Promise<void>;
+    createContainer({ imageName, volumes, doNotPullImage, tag, }: Readonly<{
+        imageName: string;
+        volumes?: Array<{
+            hostPath: string;
+            containerPath: string;
+        }>;
+        doNotPullImage?: boolean;
+        tag?: string;
+    }>): Promise<{
+        Id: string;
+    }>;
+    findOrCreateContainer({ imageName, volumes, doNotPullImage, tag, }: Readonly<{
+        imageName: string;
+        volumes?: Array<{
+            hostPath: string;
+            containerPath: string;
+        }>;
+        doNotPullImage?: boolean;
+        tag: string;
+    }>): Promise<{
+        Id: string;
+        isNew: boolean;
+    }>;
+    startContainer(): Promise<void>;
+    connectToContainer(containerId: string): Promise<void>;
+    stopContainers({ tag, remove, timeout, }: Readonly<{
+        tag?: string;
+        remove?: boolean;
+        timeout?: number;
+    }>): Promise<Array<{
+        Id: string;
+        Action: 'stopped' | 'removed';
+    }>>;
+    listContainers(all?: boolean): Promise<AxDockerContainer[]>;
+    getContainerLogs(): Promise<string>;
+    executeCommand(command: string): Promise<string>;
+    private getContainerInfo;
+    private waitForContainerToBeRunning;
+    private fetchDockerAPI;
+    toFunction(): AxFunction;
 }
 
 declare class AxEmbeddingAdapter {
@@ -4667,55 +4592,50 @@ declare class AxEmbeddingAdapter {
     toFunction(): AxFunction;
 }
 
-/**
- * Calculates the Exact Match (EM) score between a prediction and ground truth.
- *
- * The EM score is a strict metric used in machine learning to assess if the predicted
- * answer matches the ground truth exactly, commonly used in tasks like question answering.
- *
- * @param prediction The predicted text.
- * @param groundTruth The actual correct text.
- * @returns A number (1.0 for exact match, 0.0 otherwise).
- */
-declare function emScore(prediction: string, groundTruth: string): number;
-/**
- * Calculates the F1 score between a prediction and ground truth.
- *
- * The F1 score is a harmonic mean of precision and recall, widely used in NLP to measure
- * a model's accuracy in considering both false positives and false negatives, offering a
- * balance for evaluating classification models.
- *
- * @param prediction The predicted text.
- * @param groundTruth The actual correct text.
- * @returns The F1 score as a number.
- */
-declare function f1Score(prediction: string, groundTruth: string): number;
-/**
- * Calculates a novel F1 score, taking into account a history of interaction and excluding stopwords.
- *
- * This metric extends the F1 score by considering contextual relevance and filtering out common words
- * that might skew the assessment of the prediction's quality, especially in conversational models or
- * when historical context is relevant.
- *
- * @param history The historical context or preceding interactions.
- * @param prediction The predicted text.
- * @param groundTruth The actual correct text.
- * @param returnRecall Optionally return the recall score instead of F1.
- * @returns The novel F1 or recall score as a number.
- */
-declare function novelF1ScoreOptimized(history: string, prediction: string, groundTruth: string, returnRecall?: boolean): number;
-declare const AxEvalUtil: {
-    emScore: typeof emScore;
-    f1Score: typeof f1Score;
-    novelF1ScoreOptimized: typeof novelF1ScoreOptimized;
-};
+interface JSONRPCRequest<T> {
+    jsonrpc: '2.0';
+    id: string | number;
+    method: string;
+    params?: T;
+}
+interface JSONRPCSuccessResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string | number;
+    result: T;
+}
+interface JSONRPCErrorResponse {
+    jsonrpc: '2.0';
+    id: string | number;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+type JSONRPCResponse<T = unknown> = JSONRPCSuccessResponse<T> | JSONRPCErrorResponse;
+interface JSONRPCNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
 
-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> {
-    private reg;
-    constructor();
-    register(instance: AxInstanceRegistryItem<T, IN, OUT>): void;
-    [Symbol.iterator](): Generator<AxInstanceRegistryItem<T, IN, OUT> | undefined, void, unknown>;
+interface AxMCPTransport {
+    /**
+     * Sends a JSON-RPC request or notification and returns the response
+     * @param message The JSON-RPC request or notification to send
+     * @returns A Promise that resolves to the JSON-RPC response
+     */
+    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    /**
+     * Sends a JSON-RPC notification
+     * @param message The JSON-RPC notification to send
+     */
+    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    /**
+     * Connects to the transport if needed
+     * This method is optional and only required for transports that need connection setup
+     */
+    connect?(): Promise<void>;
 }
 
 /**
@@ -4777,89 +4697,173 @@ declare class AxMCPClient {
     private sendNotification;
 }
 
-interface StdioTransportConfig {
-    command: string;
-    args?: string[];
-    env?: NodeJS.ProcessEnv;
-}
-declare class AxMCPStdioTransport implements AxMCPTransport {
-    private process;
-    private rl;
-    private pendingResponses;
-    constructor(config: Readonly<StdioTransportConfig>);
-    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
-    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+declare class AxMCPHTTPSSETransport implements AxMCPTransport {
+    private endpoint;
+    private sseUrl;
+    private eventSource?;
+    constructor(sseUrl: string);
     connect(): Promise<void>;
+    send(message: JSONRPCRequest<unknown> | JSONRPCNotification): Promise<JSONRPCResponse<unknown>>;
+    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
 }
-
-type AxAIServiceListItem<TModel = unknown, TEmbedModel = unknown> = {
-    key: string;
-    service: AxAIService<TModel, TEmbedModel>;
-    description: string;
-    isInternal?: boolean;
-};
-declare class AxMultiServiceRouter implements AxAIService<string, string> {
-    private options?;
-    private lastUsedService?;
-    private services;
+interface AxMCPStreamableHTTPTransportOptions {
     /**
-     * Constructs a new multi-service router.
-     * It validates that each service provides a unique set of model keys,
-     * then builds a lookup (map) for routing the chat/embed requests.
+     * Custom headers to include with all HTTP requests
+     * Note: Content-Type, Accept, and Mcp-Session-Id are managed automatically
      */
-    constructor(services: (AxAIServiceListItem<string, string> | AxAIService<string, string>)[]);
-    getLastUsedChatModel(): string | undefined;
-    getLastUsedEmbedModel(): string | undefined;
-    getLastUsedModelConfig(): AxModelConfig | undefined;
+    headers?: Record<string, string>;
     /**
-     * Delegates the chat call to the service matching the provided model key.
+     * Authorization header value (convenience for common use case)
+     * If provided, will be added to the headers as 'Authorization'
      */
-    chat(req: Readonly<AxChatRequest<string>>, options?: Readonly<AxAIPromptConfig & AxAIServiceActionOptions<string, string>>): Promise<AxChatResponse | ReadableStream<AxChatResponse>>;
+    authorization?: string;
+}
+/**
+ * AxMCPStreambleHTTPTransport implements the 2025-03-26 Streamable HTTP transport specification
+ * This transport uses a single HTTP endpoint that supports both POST and GET methods
+ */
+declare class AxMCPStreambleHTTPTransport implements AxMCPTransport {
+    private mcpEndpoint;
+    private sessionId?;
+    private eventSource?;
+    private pendingRequests;
+    private messageHandler?;
+    private customHeaders;
+    constructor(mcpEndpoint: string, options?: AxMCPStreamableHTTPTransportOptions);
     /**
-     * Delegates the embed call to the service matching the provided embed model key.
+     * Update custom headers (useful for refreshing tokens)
      */
-    embed(req: Readonly<AxEmbedRequest<string>>, options?: Readonly<AxAIServiceActionOptions<string, string>>): Promise<AxEmbedResponse>;
+    setHeaders(headers: Record<string, string>): void;
     /**
-     * Returns a composite ID built from the IDs of the underlying services.
+     * Update authorization header (convenience method)
      */
-    getId(): string;
+    setAuthorization(authorization: string): void;
     /**
-     * Returns the name of this router.
+     * Get a copy of the current custom headers
      */
-    getName(): string;
+    getHeaders(): Record<string, string>;
     /**
-     * Aggregates all available models across the underlying services.
+     * Build headers for HTTP requests, merging custom headers with required ones
      */
-    getModelList(): AxAIModelList;
+    private buildHeaders;
     /**
-     * If a model key is provided, delegate to the corresponding service's features.
-     * Otherwise, returns a default feature set.
+     * Set a handler for incoming server messages (requests/notifications)
+     */
+    setMessageHandler(handler: (message: JSONRPCRequest<unknown> | JSONRPCNotification) => void): void;
+    connect(): Promise<void>;
+    /**
+     * Opens an SSE stream to listen for server-initiated messages
+     */
+    openListeningStream(): Promise<void>;
+    /**
+     * Opens an SSE stream using fetch API to support custom headers
      */
-    getFeatures(model?: string): {
-        functions: boolean;
-        streaming: boolean;
-        functionCot?: boolean;
-    };
+    private openListeningStreamWithFetch;
+    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    private handleSSEResponse;
+    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
     /**
-     * Returns aggregated metrics from the underlying service.
-     * Uses the metrics from the last service that was used,
-     * or falls back to the first service if none has been used.
+     * Explicitly terminate the session (if supported by server)
      */
-    getMetrics(): AxAIServiceMetrics;
+    terminateSession(): Promise<void>;
     /**
-     * Sets options on all underlying services.
+     * Close any open connections
      */
-    setOptions(options: Readonly<AxAIServiceOptions>): void;
+    close(): void;
+}
+
+interface StdioTransportConfig {
+    command: string;
+    args?: string[];
+    env?: NodeJS.ProcessEnv;
+}
+declare class AxMCPStdioTransport implements AxMCPTransport {
+    private process;
+    private rl;
+    private pendingResponses;
+    constructor(config: Readonly<StdioTransportConfig>);
+    send(message: Readonly<JSONRPCRequest<unknown>>): Promise<JSONRPCResponse<unknown>>;
+    sendNotification(message: Readonly<JSONRPCNotification>): Promise<void>;
+    connect(): Promise<void>;
+}
+
+/**
+ * Interface for agents that can be used as child agents.
+ * Provides methods to get the agent's function definition and features.
+ */
+interface AxAgentic<IN extends AxGenIn, OUT extends AxGenOut> extends AxTunable<IN, OUT>, AxUsable {
+    getFunction(): AxFunction;
+    getFeatures(): AxAgentFeatures;
+}
+type AxAgentOptions = Omit<AxProgramForwardOptions, 'functions'> & {
+    disableSmartModelRouting?: boolean;
+    /** List of field names that should not be automatically passed from parent to child agents */
+    excludeFieldsFromPassthrough?: string[];
+    debug?: boolean;
+};
+interface AxAgentFeatures {
+    /** Whether this agent can use smart model routing (requires an AI service) */
+    canConfigureSmartModelRouting: boolean;
+    /** List of fields that this agent excludes from parent->child value passing */
+    excludeFieldsFromPassthrough: string[];
+}
+/**
+ * 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.
+ */
+declare class AxAgent<IN extends AxGenIn, OUT extends AxGenOut> implements AxAgentic<IN, OUT> {
+    private ai?;
+    private program;
+    private functions?;
+    private agents?;
+    private disableSmartModelRouting?;
+    private excludeFieldsFromPassthrough;
+    private debug?;
+    private name;
+    private func;
+    constructor({ ai, name, description, definition, signature, agents, functions, }: Readonly<{
+        ai?: Readonly<AxAIService>;
+        name: string;
+        description: string;
+        definition?: string;
+        signature: NonNullable<ConstructorParameters<typeof AxSignature>[0]>;
+        agents?: AxAgentic<IN, OUT>[];
+        functions?: AxInputFunctionType;
+    }>, options?: Readonly<AxAgentOptions>);
+    setExamples(examples: Readonly<AxProgramExamples<IN, OUT>>, options?: Readonly<AxSetExamplesOptions>): void;
+    setId(id: string): void;
+    setParentId(parentId: string): void;
+    getTraces(): AxProgramTrace<IN, OUT>[];
+    setDemos(demos: readonly AxProgramDemos<IN, OUT>[]): void;
+    getUsage(): (AxModelUsage & {
+        ai: string;
+        model: string;
+    })[];
+    resetUsage(): void;
+    getFunction(): AxFunction;
+    getFeatures(): AxAgentFeatures;
     /**
-     * Returns the options from the last used service,
-     * or falls back to the first service if none has been used.
+     * Initializes the agent's execution context, processing child agents and their functions.
      */
-    getOptions(): Readonly<AxAIServiceOptions>;
+    private init;
+    forward(parentAi: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramForwardOptions>): Promise<OUT>;
+    streamingForward(parentAi: Readonly<AxAIService>, values: IN | AxMessage<IN>[], options?: Readonly<AxProgramStreamingForwardOptions>): AxGenStreamingOut<OUT>;
     /**
-     * Returns the logger from the last used service,
-     * or falls back to the first service if none has been used.
+     * Updates the agent's description.
+     * This updates both the stored description and the function's description.
+     *
+     * @param description - New description for the agent (must be at least 20 characters)
+     * @throws Error if description is too short
      */
-    getLogger(): AxLoggerFunction;
+    setDescription(description: string): void;
+    setDefinition(definition: string): 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 & {
+        setVisibleReasoning?: boolean;
+    }>);
 }
 
 declare class AxRAG extends AxChainOfThought<{
@@ -4885,85 +4889,75 @@ declare class AxRAG extends AxChainOfThought<{
     }>;
 }
 
-declare const AxStringUtil: {
-    trimNonAlphaNum: (str: string) => string;
-    splitIntoTwo: (str: string, separator: Readonly<RegExp | string>) => string[];
-    dedup: (seq: readonly string[]) => string[];
-    extractIdAndText: (input: string) => {
-        id: number;
-        text: string;
-    };
-    extractIndexPrefixedText: (input: string) => string;
-    batchArray: <T>(arr: readonly T[], size: number) => T[][];
+declare const axSpanAttributes: {
+    LLM_SYSTEM: string;
+    LLM_OPERATION_NAME: string;
+    LLM_REQUEST_MODEL: string;
+    LLM_REQUEST_MAX_TOKENS: string;
+    LLM_REQUEST_TEMPERATURE: string;
+    LLM_REQUEST_TOP_K: string;
+    LLM_REQUEST_FREQUENCY_PENALTY: string;
+    LLM_REQUEST_PRESENCE_PENALTY: string;
+    LLM_REQUEST_STOP_SEQUENCES: string;
+    LLM_REQUEST_LLM_IS_STREAMING: string;
+    LLM_REQUEST_TOP_P: string;
+    LLM_USAGE_INPUT_TOKENS: string;
+    LLM_USAGE_OUTPUT_TOKENS: string;
+    LLM_USAGE_TOTAL_TOKENS: string;
+    LLM_USAGE_THOUGHTS_TOKENS: string;
+    DB_SYSTEM: string;
+    DB_TABLE: string;
+    DB_NAMESPACE: string;
+    DB_ID: string;
+    DB_QUERY_TEXT: string;
+    DB_VECTOR: string;
+    DB_OPERATION_NAME: string;
+    DB_VECTOR_QUERY_TOP_K: string;
+    DB_QUERY_EMBEDDINGS: string;
+    DB_QUERY_RESULT: string;
+    DB_QUERY_EMBEDDINGS_VECTOR: string;
+    DB_QUERY_RESULT_ID: string;
+    DB_QUERY_RESULT_SCORE: string;
+    DB_QUERY_RESULT_DISTANCE: string;
+    DB_QUERY_RESULT_METADATA: string;
+    DB_QUERY_RESULT_VECTOR: string;
+    DB_QUERY_RESULT_DOCUMENT: string;
 };
-
-declare const axGlobals: {
-    signatureStrict: boolean;
-    tracer: Tracer | undefined;
-    meter: Meter | undefined;
+declare const axSpanEvents: {
+    GEN_AI_USER_MESSAGE: string;
+    GEN_AI_SYSTEM_MESSAGE: string;
+    GEN_AI_ASSISTANT_MESSAGE: string;
+    GEN_AI_TOOL_MESSAGE: string;
+    GEN_AI_CHOICE: string;
+    GEN_AI_USAGE: string;
 };
-
-declare const axModelInfoAnthropic: AxModelInfo[];
-
-declare const axModelInfoCohere: AxModelInfo[];
-
-declare const axModelInfoDeepSeek: AxModelInfo[];
-
-/**
- * AxAIGoogleGemini: Model information
- */
-declare const axModelInfoGoogleGemini: AxModelInfo[];
-
-declare const axModelInfoGrok: AxModelInfo[];
-
-/**
- * AxAIGroq: Model information
- */
-declare const axModelInfoGroq: AxModelInfo[];
-
-/**
- * HuggingFace: Model information
- */
-declare const axModelInfoHuggingFace: AxModelInfo[];
-
-declare const axModelInfoMistral: AxModelInfo[];
-
-/**
- * OpenAI: Model information
- */
-declare const axModelInfoReka: AxModelInfo[];
-
-declare const axModelInfoTogether: AxModelInfo[];
-
-interface AxAIMetricsInstruments {
-    latencyHistogram?: Histogram;
-    errorCounter?: Counter;
-    requestCounter?: Counter;
-    tokenCounter?: Counter;
-    inputTokenCounter?: Counter;
-    outputTokenCounter?: Counter;
-    errorRateGauge?: Gauge;
-    meanLatencyGauge?: Gauge;
-    p95LatencyGauge?: Gauge;
-    p99LatencyGauge?: Gauge;
-    streamingRequestsCounter?: Counter;
-    functionCallsCounter?: Counter;
-    functionCallLatencyHistogram?: Histogram;
-    requestSizeHistogram?: Histogram;
-    responseSizeHistogram?: Histogram;
-    temperatureGauge?: Gauge;
-    maxTokensGauge?: Gauge;
-    estimatedCostCounter?: Counter;
-    promptLengthHistogram?: Histogram;
-    contextWindowUsageGauge?: Gauge;
-    timeoutsCounter?: Counter;
-    abortsCounter?: Counter;
-    thinkingBudgetUsageCounter?: Counter;
-    multimodalRequestsCounter?: Counter;
+declare enum AxLLMRequestTypeValues {
+    COMPLETION = "completion",
+    CHAT = "chat",
+    RERANK = "rerank",
+    UNKNOWN = "unknown"
+}
+declare enum AxSpanKindValues {
+    WORKFLOW = "workflow",
+    TASK = "task",
+    AGENT = "agent",
+    TOOL = "tool",
+    UNKNOWN = "unknown"
 }
 
-interface AxSamplePickerOptions<OUT extends AxGenOut> {
-    resultPicker?: AxResultPickerFunction<OUT>;
+interface AxRateLimiterTokenUsageOptions {
+    debug?: boolean;
+}
+declare class AxRateLimiterTokenUsage {
+    private options?;
+    private maxTokens;
+    private refillRate;
+    private currentTokens;
+    private lastRefillTime;
+    constructor(maxTokens: number, refillRate: number, options?: Readonly<AxRateLimiterTokenUsageOptions>);
+    private refillTokens;
+    private waitUntilTokensAvailable;
+    acquire(tokens: number): Promise<void>;
 }
 
-export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, type AxAIPromptConfig, AxAIRefusalError, AxAIReka, type AxAIRekaArgs, type AxAIRekaChatRequest, type AxAIRekaChatResponse, type AxAIRekaChatResponseDelta, type AxAIRekaConfig, AxAIRekaModel, type AxAIRekaUsage, type AxAIService, AxAIServiceAbortedError, type AxAIServiceActionOptions, AxAIServiceAuthenticationError, AxAIServiceError, type AxAIServiceImpl, type AxAIServiceMetrics, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, AxAITogether, type AxAITogetherArgs, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, AxChainOfThought, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type AxFieldDescriptor, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, AxFlowTypedSubContextImpl, type AxFunction, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, 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, AxJSInterpreter, AxJSInterpreterPermission, AxLLMRequestTypeValues, type AxLoggerFunction, type AxLoggerTag, AxMCPClient, AxMCPHTTPSSETransport, AxMCPStdioTransport, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPTransport, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramTrace, type AxProgramUsage, AxPromptTemplate, type AxPromptTemplateOptions, AxRAG, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, type AxSignatureConfig, type AxSignatureTemplateValue, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultLogger, axCreateDefaultTextLogger, axCreateOptimizerLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, f, s };
+export { AxAI, AxAIAnthropic, type AxAIAnthropicArgs, type AxAIAnthropicChatError, type AxAIAnthropicChatRequest, type AxAIAnthropicChatRequestCacheParam, type AxAIAnthropicChatResponse, type AxAIAnthropicChatResponseDelta, type AxAIAnthropicConfig, type AxAIAnthropicContentBlockDeltaEvent, type AxAIAnthropicContentBlockStartEvent, type AxAIAnthropicContentBlockStopEvent, type AxAIAnthropicErrorEvent, type AxAIAnthropicMessageDeltaEvent, type AxAIAnthropicMessageStartEvent, type AxAIAnthropicMessageStopEvent, AxAIAnthropicModel, type AxAIAnthropicPingEvent, type AxAIAnthropicThinkingConfig, type AxAIAnthropicThinkingTokenBudgetLevels, AxAIAnthropicVertexModel, type AxAIArgs, AxAIAzureOpenAI, type AxAIAzureOpenAIArgs, type AxAIAzureOpenAIConfig, AxAICohere, type AxAICohereArgs, type AxAICohereChatRequest, type AxAICohereChatRequestToolResults, type AxAICohereChatResponse, type AxAICohereChatResponseDelta, type AxAICohereChatResponseToolCalls, type AxAICohereConfig, AxAICohereEmbedModel, type AxAICohereEmbedRequest, type AxAICohereEmbedResponse, AxAICohereModel, AxAIDeepSeek, type AxAIDeepSeekArgs, AxAIDeepSeekModel, type AxAIEmbedModels, type AxAIFeatures, AxAIGoogleGemini, type AxAIGoogleGeminiArgs, type AxAIGoogleGeminiBatchEmbedRequest, type AxAIGoogleGeminiBatchEmbedResponse, type AxAIGoogleGeminiChatRequest, type AxAIGoogleGeminiChatResponse, type AxAIGoogleGeminiChatResponseDelta, type AxAIGoogleGeminiConfig, type AxAIGoogleGeminiContent, type AxAIGoogleGeminiContentPart, AxAIGoogleGeminiEmbedModel, AxAIGoogleGeminiEmbedTypes, type AxAIGoogleGeminiGenerationConfig, AxAIGoogleGeminiModel, type AxAIGoogleGeminiOptionsTools, AxAIGoogleGeminiSafetyCategory, type AxAIGoogleGeminiSafetySettings, AxAIGoogleGeminiSafetyThreshold, type AxAIGoogleGeminiThinkingConfig, type AxAIGoogleGeminiThinkingTokenBudgetLevels, type AxAIGoogleGeminiTool, type AxAIGoogleGeminiToolConfig, type AxAIGoogleGeminiToolFunctionDeclaration, type AxAIGoogleGeminiToolGoogleSearchRetrieval, type AxAIGoogleVertexBatchEmbedRequest, type AxAIGoogleVertexBatchEmbedResponse, AxAIGrok, type AxAIGrokArgs, type AxAIGrokChatRequest, AxAIGrokEmbedModels, AxAIGrokModel, type AxAIGrokOptionsTools, type AxAIGrokSearchSource, AxAIGroq, type AxAIGroqArgs, AxAIGroqModel, AxAIHuggingFace, type AxAIHuggingFaceArgs, type AxAIHuggingFaceConfig, AxAIHuggingFaceModel, type AxAIHuggingFaceRequest, type AxAIHuggingFaceResponse, type AxAIInputModelList, type AxAIMemory, type AxAIMetricsInstruments, AxAIMistral, type AxAIMistralArgs, type AxAIMistralChatRequest, AxAIMistralEmbedModels, AxAIMistralModel, type AxAIModelList, type AxAIModelListBase, type AxAIModels, AxAIOllama, type AxAIOllamaAIConfig, type AxAIOllamaArgs, AxAIOpenAI, type AxAIOpenAIAnnotation, type AxAIOpenAIArgs, AxAIOpenAIBase, type AxAIOpenAIBaseArgs, type AxAIOpenAIChatRequest, type AxAIOpenAIChatResponse, type AxAIOpenAIChatResponseDelta, type AxAIOpenAIConfig, AxAIOpenAIEmbedModel, type AxAIOpenAIEmbedRequest, type AxAIOpenAIEmbedResponse, type AxAIOpenAILogprob, AxAIOpenAIModel, type AxAIOpenAIResponseDelta, AxAIOpenAIResponses, type AxAIOpenAIResponsesArgs, AxAIOpenAIResponsesBase, type AxAIOpenAIResponsesCodeInterpreterToolCall, type AxAIOpenAIResponsesComputerToolCall, type AxAIOpenAIResponsesConfig, type AxAIOpenAIResponsesContentPartAddedEvent, type AxAIOpenAIResponsesContentPartDoneEvent, type AxAIOpenAIResponsesDefineFunctionTool, type AxAIOpenAIResponsesErrorEvent, type AxAIOpenAIResponsesFileSearchCallCompletedEvent, type AxAIOpenAIResponsesFileSearchCallInProgressEvent, type AxAIOpenAIResponsesFileSearchCallSearchingEvent, type AxAIOpenAIResponsesFileSearchToolCall, type AxAIOpenAIResponsesFunctionCallArgumentsDeltaEvent, type AxAIOpenAIResponsesFunctionCallArgumentsDoneEvent, type AxAIOpenAIResponsesFunctionCallItem, type AxAIOpenAIResponsesImageGenerationCallCompletedEvent, type AxAIOpenAIResponsesImageGenerationCallGeneratingEvent, type AxAIOpenAIResponsesImageGenerationCallInProgressEvent, type AxAIOpenAIResponsesImageGenerationCallPartialImageEvent, type AxAIOpenAIResponsesImageGenerationToolCall, AxAIOpenAIResponsesImpl, type AxAIOpenAIResponsesInputAudioContentPart, type AxAIOpenAIResponsesInputContentPart, type AxAIOpenAIResponsesInputFunctionCallItem, type AxAIOpenAIResponsesInputFunctionCallOutputItem, type AxAIOpenAIResponsesInputImageUrlContentPart, type AxAIOpenAIResponsesInputItem, type AxAIOpenAIResponsesInputMessageItem, type AxAIOpenAIResponsesInputTextContentPart, type AxAIOpenAIResponsesLocalShellToolCall, type AxAIOpenAIResponsesMCPCallArgumentsDeltaEvent, type AxAIOpenAIResponsesMCPCallArgumentsDoneEvent, type AxAIOpenAIResponsesMCPCallCompletedEvent, type AxAIOpenAIResponsesMCPCallFailedEvent, type AxAIOpenAIResponsesMCPCallInProgressEvent, type AxAIOpenAIResponsesMCPListToolsCompletedEvent, type AxAIOpenAIResponsesMCPListToolsFailedEvent, type AxAIOpenAIResponsesMCPListToolsInProgressEvent, type AxAIOpenAIResponsesMCPToolCall, AxAIOpenAIResponsesModel, type AxAIOpenAIResponsesOutputItem, type AxAIOpenAIResponsesOutputItemAddedEvent, type AxAIOpenAIResponsesOutputItemDoneEvent, type AxAIOpenAIResponsesOutputMessageItem, type AxAIOpenAIResponsesOutputRefusalContentPart, type AxAIOpenAIResponsesOutputTextAnnotationAddedEvent, type AxAIOpenAIResponsesOutputTextContentPart, type AxAIOpenAIResponsesOutputTextDeltaEvent, type AxAIOpenAIResponsesOutputTextDoneEvent, type AxAIOpenAIResponsesReasoningDeltaEvent, type AxAIOpenAIResponsesReasoningDoneEvent, type AxAIOpenAIResponsesReasoningItem, type AxAIOpenAIResponsesReasoningSummaryDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryDoneEvent, type AxAIOpenAIResponsesReasoningSummaryPart, type AxAIOpenAIResponsesReasoningSummaryPartAddedEvent, type AxAIOpenAIResponsesReasoningSummaryPartDoneEvent, type AxAIOpenAIResponsesReasoningSummaryTextDeltaEvent, type AxAIOpenAIResponsesReasoningSummaryTextDoneEvent, type AxAIOpenAIResponsesRefusalDeltaEvent, type AxAIOpenAIResponsesRefusalDoneEvent, type AxAIOpenAIResponsesRequest, type AxAIOpenAIResponsesResponse, type AxAIOpenAIResponsesResponseCompletedEvent, type AxAIOpenAIResponsesResponseCreatedEvent, type AxAIOpenAIResponsesResponseDelta, type AxAIOpenAIResponsesResponseFailedEvent, type AxAIOpenAIResponsesResponseInProgressEvent, type AxAIOpenAIResponsesResponseIncompleteEvent, type AxAIOpenAIResponsesResponseQueuedEvent, type AxAIOpenAIResponsesStreamEvent, type AxAIOpenAIResponsesStreamEventBase, type AxAIOpenAIResponsesToolCall, type AxAIOpenAIResponsesToolCallBase, type AxAIOpenAIResponsesToolChoice, type AxAIOpenAIResponsesToolDefinition, type AxAIOpenAIResponsesWebSearchCallCompletedEvent, type AxAIOpenAIResponsesWebSearchCallInProgressEvent, type AxAIOpenAIResponsesWebSearchCallSearchingEvent, type AxAIOpenAIResponsesWebSearchToolCall, type AxAIOpenAIUrlCitation, type AxAIOpenAIUsage, type AxAIPromptConfig, AxAIRefusalError, AxAIReka, type AxAIRekaArgs, type AxAIRekaChatRequest, type AxAIRekaChatResponse, type AxAIRekaChatResponseDelta, type AxAIRekaConfig, AxAIRekaModel, type AxAIRekaUsage, type AxAIService, AxAIServiceAbortedError, type AxAIServiceActionOptions, AxAIServiceAuthenticationError, AxAIServiceError, type AxAIServiceImpl, type AxAIServiceMetrics, AxAIServiceNetworkError, type AxAIServiceOptions, AxAIServiceResponseError, AxAIServiceStatusError, AxAIServiceStreamTerminatedError, AxAIServiceTimeoutError, AxAITogether, type AxAITogetherArgs, type AxAPI, type AxAPIConfig, AxAgent, type AxAgentFeatures, type AxAgentOptions, type AxAgentic, AxApacheTika, type AxApacheTikaArgs, type AxApacheTikaConvertOptions, type AxAssertion, AxAssertionError, AxBalancer, type AxBalancerOptions, AxBaseAI, type AxBaseAIArgs, AxBaseOptimizer, type AxBootstrapCompileOptions, AxBootstrapFewShot, type AxBootstrapOptimizerOptions, AxChainOfThought, type AxChatRequest, type AxChatResponse, type AxChatResponseFunctionCall, type AxChatResponseResult, type AxCheckpointLoadFn, type AxCheckpointSaveFn, type AxCompileOptions, type AxCostTracker, type AxCostTrackerOptions, AxDB, type AxDBArgs, AxDBBase, type AxDBBaseArgs, type AxDBBaseOpOptions, AxDBCloudflare, type AxDBCloudflareArgs, type AxDBCloudflareOpOptions, type AxDBLoaderOptions, AxDBManager, type AxDBManagerArgs, type AxDBMatch, AxDBMemory, type AxDBMemoryArgs, type AxDBMemoryOpOptions, AxDBPinecone, type AxDBPineconeArgs, type AxDBPineconeOpOptions, type AxDBQueryRequest, type AxDBQueryResponse, type AxDBQueryService, type AxDBService, type AxDBState, type AxDBUpsertRequest, type AxDBUpsertResponse, AxDBWeaviate, type AxDBWeaviateArgs, type AxDBWeaviateOpOptions, type AxDataRow, AxDefaultCostTracker, AxDefaultResultReranker, type AxDockerContainer, AxDockerSession, type AxEmbedRequest, type AxEmbedResponse, AxEmbeddingAdapter, type AxErrorCategory, AxEvalUtil, type AxEvaluateArgs, type AxExample, type AxField, type AxFieldDescriptor, type AxFieldProcessor, type AxFieldProcessorProcess, type AxFieldTemplateFn, type AxFieldType, type AxFieldValue, AxFlow, AxFlowTypedSubContextImpl, type AxFunction, AxFunctionError, type AxFunctionHandler, type AxFunctionJSONSchema, AxFunctionProcessor, type AxFunctionResult, AxGen, type AxGenDeltaOut, type AxGenIn, type AxGenMetricsInstruments, type AxGenOut, type AxGenStreamingOut, AxGenerateError, type AxGenerateErrorDetails, type AxGenerateResult, AxHFDataLoader, type AxIField, type AxInputFunctionType, AxInstanceRegistry, type AxInternalChatRequest, type AxInternalEmbedRequest, AxLLMRequestTypeValues, type AxLoggerFunction, type AxLoggerTag, AxMCPClient, AxMCPHTTPSSETransport, AxMCPStdioTransport, type AxMCPStreamableHTTPTransportOptions, AxMCPStreambleHTTPTransport, type AxMCPTransport, AxMemory, type AxMemoryData, type AxMessage, type AxMetricFn, type AxMetricFnArgs, type AxMetricsConfig, AxMiPRO, type AxMiPROCompileOptions, type AxMiPROOptimizerOptions, type AxMiPROResult, AxMockAIService, type AxMockAIServiceConfig, type AxModelConfig, type AxModelInfo, type AxModelInfoWithProvider, type AxModelUsage, type AxMultiMetricFn, AxMultiServiceRouter, type AxOptimizationCheckpoint, type AxOptimizationProgress, type AxOptimizationStats, type AxOptimizer, type AxOptimizerArgs, type AxOptimizerMetricsConfig, type AxOptimizerMetricsInstruments, type AxOptimizerResult, type AxParetoResult, AxProgram, type AxProgramDemos, type AxProgramExamples, type AxProgramForwardOptions, type AxProgramOptions, type AxProgramStreamingForwardOptions, type AxProgramTrace, type AxProgramUsage, AxPromptTemplate, type AxPromptTemplateOptions, AxRAG, type AxRateLimiterFunction, AxRateLimiterTokenUsage, type AxRateLimiterTokenUsageOptions, type AxRerankerIn, type AxRerankerOut, type AxResponseHandlerArgs, type AxResultPickerFunction, type AxResultPickerFunctionFieldResults, type AxResultPickerFunctionFunctionResults, type AxRewriteIn, type AxRewriteOut, type AxSamplePickerOptions, type AxSetExamplesOptions, AxSignature, type AxSignatureConfig, type AxSignatureTemplateValue, AxSimpleClassifier, AxSimpleClassifierClass, type AxSimpleClassifierForwardOptions, AxSpanKindValues, type AxStreamingAssertion, type AxStreamingEvent, type AxStreamingFieldProcessorProcess, AxStringUtil, AxTestPrompt, type AxTokenUsage, type AxTunable, type AxUsable, ax, axAIAnthropicDefaultConfig, axAIAnthropicVertexDefaultConfig, axAIAzureOpenAIBestConfig, axAIAzureOpenAICreativeConfig, axAIAzureOpenAIDefaultConfig, axAIAzureOpenAIFastConfig, axAICohereCreativeConfig, axAICohereDefaultConfig, axAIDeepSeekCodeConfig, axAIDeepSeekDefaultConfig, axAIGoogleGeminiDefaultConfig, axAIGoogleGeminiDefaultCreativeConfig, axAIGrokBestConfig, axAIGrokDefaultConfig, axAIHuggingFaceCreativeConfig, axAIHuggingFaceDefaultConfig, axAIMistralBestConfig, axAIMistralDefaultConfig, axAIOllamaDefaultConfig, axAIOllamaDefaultCreativeConfig, axAIOpenAIBestConfig, axAIOpenAICreativeConfig, axAIOpenAIDefaultConfig, axAIOpenAIFastConfig, axAIOpenAIResponsesBestConfig, axAIOpenAIResponsesCreativeConfig, axAIOpenAIResponsesDefaultConfig, axAIRekaBestConfig, axAIRekaCreativeConfig, axAIRekaDefaultConfig, axAIRekaFastConfig, axAITogetherDefaultConfig, axBaseAIDefaultConfig, axBaseAIDefaultCreativeConfig, axCheckMetricsHealth, axCreateDefaultColorLogger, axCreateDefaultTextLogger, axCreateOptimizerLogger, axDefaultMetricsConfig, axDefaultOptimizerLogger, axDefaultOptimizerMetricsConfig, axGetMetricsConfig, axGetOptimizerMetricsConfig, axGlobals, axModelInfoAnthropic, axModelInfoCohere, axModelInfoDeepSeek, axModelInfoGoogleGemini, axModelInfoGrok, axModelInfoGroq, axModelInfoHuggingFace, axModelInfoMistral, axModelInfoOpenAI, axModelInfoOpenAIResponses, axModelInfoReka, axModelInfoTogether, axSpanAttributes, axSpanEvents, axUpdateMetricsConfig, axUpdateOptimizerMetricsConfig, axValidateChatRequestMessage, axValidateChatResponseResult, f, s };