@adaline/gateway/dist/index.d.mts

Adaline Gateway

import { GatewayBaseError, ToolCallContentType, ToolResponseContentType } from '@adaline/types';
import { Context, Tracer, Meter } from '@opentelemetry/api';
import { z } from 'zod';
import { ChatModelV1, EmbeddingModelV1 } from '@adaline/provider';
import { AxiosInstance } from 'axios';

declare class GatewayError extends Error {
    status: number;
    data: unknown;
    constructor(message: string, status?: number, data?: unknown);
}
declare class GatewayTelemetryError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isGatewayTelemetryError(error: unknown): error is GatewayTelemetryError;
}

type HttpClientOptions = {
    retry?: {
        maxAttempts: number;
        initialDelay: number;
        exponentialFactor: number;
    };
};
interface HttpClient {
    stream<T>(url: string, method: "get" | "post", data?: Record<string, unknown>, headers?: Record<string, string>, options?: {
        abortSignal?: AbortSignal;
    }, telemetryContext?: Context): AsyncGenerator<T, void, unknown>;
    get<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    post<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    put<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    delete<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    patch<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
}
interface HttpClientResponse<T> {
    data: T;
    headers: Record<string, string>;
    status: {
        code: number;
        text: string;
    };
}

declare class HttpClientError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isHttpClientError(error: unknown): error is HttpClientError;
}
declare class HttpRequestError extends GatewayBaseError {
    readonly info: string;
    readonly cause: {
        status: number;
        headers: Record<string, string>;
        data: unknown;
    };
    constructor(message: string, status: number | undefined, headers: Record<string, string>, data: unknown);
    static isHttpRequestError(error: unknown): error is HttpRequestError;
}

interface IsomorphicHttpClientConfig {
    timeoutInMilliseconds?: number;
    axiosInstance?: AxiosInstance;
    telemetryTracer?: Tracer;
    enableProxyAgent?: boolean;
}
declare class IsomorphicHttpClient implements HttpClient {
    private defaultTimeout?;
    private client;
    private httpProxyAgent?;
    private httpsProxyAgent?;
    private enableProxyAgent;
    constructor(config: IsomorphicHttpClientConfig);
    isNodeEnvironment: () => boolean;
    private makeRequest;
    stream<T>(url: string, method: "get" | "post", data?: Record<string, unknown>, headers?: Record<string, string>, options?: {
        abortSignal?: AbortSignal;
    }, telemetryContext?: Context): AsyncGenerator<T, void, unknown>;
    get<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    post<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    put<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    delete<T>(url: string, params?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
    patch<T>(url: string, data?: Record<string, unknown>, headers?: Record<string, string | undefined>, options?: HttpClientOptions, telemetryContext?: Context): Promise<HttpClientResponse<T>>;
}

declare class QueueTaskTimeoutError extends GatewayBaseError {
    readonly info: string;
    readonly cause: unknown;
    constructor({ info, cause }: {
        info: string;
        cause: unknown;
    });
    static isQueueTaskTimeoutError(error: unknown): error is QueueTaskTimeoutError;
}

interface Cache<T> {
    get(key: string): Promise<T | undefined>;
    set(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
}

declare class LRUCache<T extends object> implements Cache<T> {
    private cache;
    constructor(maxEntries?: number);
    get(key: string): Promise<T | undefined>;
    set(key: string, value: T): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
}

type QueueTask<Request, Response> = {
    id: string;
    request: Request;
    cache?: Cache<Response>;
    resolve: (value: Response) => void;
    reject: (error: any) => void;
    execute: (request: Request, context: Context) => Promise<Response>;
    telemetryContext: Context;
};
interface Queue<Request, Response> {
    enqueue(task: QueueTask<Request, Response>): void;
}
declare const QueueOptions: z.ZodObject<{
    maxConcurrentTasks: z.ZodNumber;
    retryCount: z.ZodNumber;
    timeout: z.ZodNumber;
    retry: z.ZodObject<{
        initialDelay: z.ZodNumber;
        exponentialFactor: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        initialDelay: number;
        exponentialFactor: number;
    }, {
        initialDelay: number;
        exponentialFactor: number;
    }>;
}, "strip", z.ZodTypeAny, {
    timeout: number;
    retry: {
        initialDelay: number;
        exponentialFactor: number;
    };
    maxConcurrentTasks: number;
    retryCount: number;
}, {
    timeout: number;
    retry: {
        initialDelay: number;
        exponentialFactor: number;
    };
    maxConcurrentTasks: number;
    retryCount: number;
}>;
type QueueOptionsType = z.infer<typeof QueueOptions>;

declare class SimpleQueue<Request, Response> implements Queue<Request, Response> {
    private options;
    private activeTasks;
    private queue;
    constructor(options: QueueOptionsType);
    enqueue(task: QueueTask<Request, Response>): void;
    private executeWithTimeout;
    private executeWithRetry;
    private processQueue;
}

type AnalyticsNodeEnvironment = {
    node: {
        version: string;
        platform: string;
        architecture: string;
    };
};
type AnalyticsBrowserEnvironment = {
    browser: {
        version: string;
        userAgent: string;
    };
};
type AnalyticsEvent = {
    event: string;
    timestamp: string;
    dimensions: {
        [key: string]: any;
    };
    status: string;
    eventVersion: string;
    gatewayVersion: string;
    environment: AnalyticsNodeEnvironment | AnalyticsBrowserEnvironment;
    userId?: string;
};
interface AnalyticsRecorder {
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    stopRecorder(): void;
}

declare class AnalyticsManager {
    private static analytics;
    static getAnalyticsRecorder(enableAnalytics: boolean): AnalyticsRecorder;
}

declare class PostAnalytics implements AnalyticsRecorder {
    private readonly eventVersion;
    private readonly gatewayVersion;
    private flushTimer;
    private flushInterval;
    private batchSize;
    private maxAttempts;
    private environment;
    private analyticsEndpointUrl;
    private events;
    constructor();
    private startFlushTimer;
    private stopFlushTimer;
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    private flushEvents;
    private sendEvents;
    stopRecorder(): void;
}

declare class NoOpAnalytics implements AnalyticsRecorder {
    record(event: AnalyticsEvent["event"], status: AnalyticsEvent["status"], dimensions: AnalyticsEvent["dimensions"]): void;
    stopRecorder(): void;
}

declare class TelemetryManager {
    static DEFAULT_TRACER_KEY: string;
    static DEFAULT_METER_KEY: string;
    private static tracer;
    private static meter;
    static setTracer(tracer: Tracer | undefined): void;
    static getTracer(): Tracer;
    static setMeter(meter: Meter | undefined): void;
    static getMeter(): Meter;
}

interface Logger {
    debug(message: string, ...params: any[]): void;
    info(message: string, ...params: any[]): void;
    warn(message: string, ...params: any[]): void;
    error(message: string, ...params: any[]): void;
    critical(message: string, ...params: any[]): void;
}

declare class LoggerManager {
    private static logger;
    static setLogger(logger: Logger | undefined): void;
    static getLogger(): Logger | undefined;
}

declare class ConsoleLogger implements Logger {
    debug(message: string, ...params: any[]): void;
    info(message: string, ...params: any[]): void;
    warn(message: string, ...params: any[]): void;
    error(message: string, ...params: any[]): void;
    critical(message: string, ...params: any[]): void;
}

declare const CompleteChatHandlerRequest: z.ZodObject<{
    cache: z.ZodType<Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    modality: "tool-response";
                    name: string;
                    id: string;
                    data: string;
                    index: number;
                    metadata?: any;
                    apiResponse?: {
                        statusCode: number;
                    } | undefined;
                } | {
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        mediaType: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "pdf";
                    file: {
                        name: string;
                        id: string;
                        size?: number | undefined;
                    };
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    value: {
                        type: "thinking";
                        thinking: string;
                        signature: string;
                    } | {
                        type: "redacted";
                        data: string;
                    };
                    modality: "reasoning";
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
                request?: {
                    type: "http";
                    url: string;
                    method: "get" | "post";
                    headers?: Record<string, string> | undefined;
                    query?: Record<string, string> | undefined;
                    body?: Record<string, any> | undefined;
                    proxyUrl?: string | undefined;
                    proxyHeaders?: Record<string, string> | undefined;
                    retry?: {
                        maxAttempts: number;
                        initialDelay: number;
                        exponentialFactor: number;
                    } | undefined;
                } | undefined;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: {
                        type: "thinking";
                        thinking: string;
                        signature: string;
                    } | {
                        type: "redacted";
                        data: string;
                    };
                    modality: "reasoning";
                    metadata?: undefined;
                } | {
                    modality: "tool-response";
                    name: string;
                    id: string;
                    data: string;
                    index: number;
                    metadata?: any;
                    apiResponse?: {
                        statusCode: number;
                    } | undefined;
                } | {
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        mediaType: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "pdf";
                    file: {
                        name: string;
                        id: string;
                        size?: number | undefined;
                    };
                    metadata?: undefined;
                } | {
                    modality: "tool-call";
                    name: string;
                    id: string;
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                promptTokens: number;
                completionTokens: number;
                totalTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>, z.ZodTypeDef, Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    modality: "tool-response";
                    name: string;
                    id: string;
                    data: string;
                    index: number;
                    metadata?: any;
                    apiResponse?: {
                        statusCode: number;
                    } | undefined;
                } | {
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        mediaType: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "pdf";
                    file: {
                        name: string;
                        id: string;
                        size?: number | undefined;
                    };
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    value: {
                        type: "thinking";
                        thinking: string;
                        signature: string;
                    } | {
                        type: "redacted";
                        data: string;
                    };
                    modality: "reasoning";
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;
                        parameters?: any;
                    };
                };
                metadata?: any;
                request?: {
                    type: "http";
                    url: string;
                    method: "get" | "post";
                    headers?: Record<string, string> | undefined;
                    query?: Record<string, string> | undefined;
                    body?: Record<string, any> | undefined;
                    proxyUrl?: string | undefined;
                    proxyHeaders?: Record<string, string> | undefined;
                    retry?: {
                        maxAttempts: number;
                        initialDelay: number;
                        exponentialFactor: number;
                    } | undefined;
                } | undefined;
            }[] | undefined;
        };
        response: {
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    value: {
                        type: "thinking";
                        thinking: string;
                        signature: string;
                    } | {
                        type: "redacted";
                        data: string;
                    };
                    modality: "reasoning";
                    metadata?: undefined;
                } | {
                    modality: "tool-response";
                    name: string;
                    id: string;
                    data: string;
                    index: number;
                    metadata?: any;
                    apiResponse?: {
                        statusCode: number;
                    } | undefined;
                } | {
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        mediaType: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "pdf";
                    file: {
                        name: string;
                        id: string;
                        size?: number | undefined;
                    };
                    metadata?: undefined;
                } | {
                    modality: "tool-call";
                    name: string;
                    id: string;
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            usage?: {
                promptTokens: number;
                completionTokens: number;
                totalTokens: number;
            } | undefined;
            logProbs?: {
                token: string;
                logProb: number;
                bytes: number[] | null;
                topLogProbs: {
                    token: string;
                    logProb: number;
                    bytes: number[] | null;
                }[];
            }[] | undefined;
        };
        cached: boolean;
        latencyInMs: number;
        provider: {
            request?: any;
            response?: any;
        };
        metadataForCallbacks?: any;
    }>>;
    model: z.ZodType<ChatModelV1<{
        name: string;
        description: string;
        roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
        modalities: ["text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning")[]];
        maxInputTokens: number;
        maxOutputTokens: number;
        config: {
            def: Record<string, {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            } | {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            } | {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            } | {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            } | {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
        price: {
            modelName: string;
            currency: string;
            tokenRanges: {
                minTokens: number;
                prices: {
                    base: {
                        inputPricePerMillion: number;
                        outputPricePerMillion: number;
                    };
                };
                maxTokens?: number | null | undefined;
            }[];
        };
        maxReasoningTokens?: number | undefined;
    }>, z.ZodTypeDef, ChatModelV1<{
        name: string;
        description: string;
        roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
        modalities: ["text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning")[]];
        maxInputTokens: number;
        maxOutputTokens: number;
        config: {
            def: Record<string, {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            } | {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            } | {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            } | {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            } | {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
        price: {
            modelName: string;
            currency: string;
            tokenRanges: {
                minTokens: number;
                prices: {
                    base: {
                        inputPricePerMillion: number;
                        outputPricePerMillion: number;
                    };
                };
                maxTokens?: number | null | undefined;
            }[];
        };
        maxReasoningTokens?: number | undefined;
    }>>;
    config: z.ZodRecord<z.ZodString, z.ZodAny>;
    messages: z.ZodArray<z.ZodObject<{
        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
        content: z.ZodArray<z.ZodDiscriminatedUnion<"modality", [z.ZodObject<{
            modality: z.ZodLiteral<"text">;
            value: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }, {
            value: string;
            modality: "text";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"image">;
            detail: z.ZodEnum<["low", "medium", "high", "auto"]>;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
                mediaType: z.ZodEnum<["png", "jpeg", "webp", "gif"]>;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            }, {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"pdf">;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"base64">;
                base64: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "base64";
                base64: string;
            }, {
                type: "base64";
                base64: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"url">;
                url: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "url";
                url: string;
            }, {
                type: "url";
                url: string;
            }>]>;
            file: z.ZodObject<{
                name: z.ZodString;
                id: z.ZodString;
                size: z.ZodOptional<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                id: string;
                size?: number | undefined;
            }, {
                name: string;
                id: string;
                size?: number | undefined;
            }>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "base64";
                base64: string;
            } | {
                type: "url";
                url: string;
            };
            modality: "pdf";
            file: {
                name: string;
                id: string;
                size?: number | undefined;
            };
            metadata?: undefined;
        }, {
            value: {
                type: "base64";
                base64: string;
            } | {
                type: "url";
                url: string;
            };
            modality: "pdf";
            file: {
                name: string;
                id: string;
                size?: number | undefined;
            };
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-call">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            arguments: z.ZodString;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }, {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"tool-response">;
            index: z.ZodNumber;
            id: z.ZodString;
            name: z.ZodString;
            data: z.ZodString;
            apiResponse: z.ZodOptional<z.ZodObject<{
                statusCode: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                statusCode: number;
            }, {
                statusCode: number;
            }>>;
            metadata: z.ZodTypeAny;
        }, "strip", z.ZodTypeAny, {
            modality: "tool-response";
            name: string;
            id: string;
            data: string;
            index: number;
            metadata?: any;
            apiResponse?: {
                statusCode: number;
            } | undefined;
        }, {
            modality: "tool-response";
            name: string;
            id: string;
            data: string;
            index: number;
            metadata?: any;
            apiResponse?: {
                statusCode: number;
            } | undefined;
        }>, z.ZodObject<{
            modality: z.ZodLiteral<"reasoning">;
            value: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"thinking">;
                thinking: z.ZodString;
                signature: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "thinking";
                thinking: string;
                signature: string;
            }, {
                type: "thinking";
                thinking: string;
                signature: string;
            }>, z.ZodObject<{
                type: z.ZodLiteral<"redacted">;
                data: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                type: "redacted";
                data: string;
            }, {
                type: "redacted";
                data: string;
            }>]>;
            metadata: z.ZodUndefined;
        }, "strip", z.ZodTypeAny, {
            value: {
                type: "thinking";
                thinking: string;
                signature: string;
            } | {
                type: "redacted";
                data: string;
            };
            modality: "reasoning";
            metadata?: undefined;
        }, {
            value: {
                type: "thinking";
                thinking: string;
                signature: string;
            } | {
                type: "redacted";
                data: string;
            };
            modality: "reasoning";
            metadata?: undefined;
        }>]>, "many">;
        metadata: z.ZodUndefined;
    }, "strip", z.ZodTypeAny, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            modality: "tool-response";
            name: string;
            id: string;
            data: string;
            index: number;
            metadata?: any;
            apiResponse?: {
                statusCode: number;
            } | undefined;
        } | {
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
            } | {
                type: "url";
                url: string;
            };
            modality: "pdf";
            file: {
                name: string;
                id: string;
                size?: number | undefined;
            };
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            value: {
                type: "thinking";
                thinking: string;
                signature: string;
            } | {
                type: "redacted";
                data: string;
            };
            modality: "reasoning";
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }, {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            modality: "tool-response";
            name: string;
            id: string;
            data: string;
            index: number;
            metadata?: any;
            apiResponse?: {
                statusCode: number;
            } | undefined;
        } | {
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
            } | {
                type: "url";
                url: string;
            };
            modality: "pdf";
            file: {
                name: string;
                id: string;
                size?: number | undefined;
            };
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            value: {
                type: "thinking";
                thinking: string;
                signature: string;
            } | {
                type: "redacted";
                data: string;
            };
            modality: "reasoning";
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }>, "many">;
    tools: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<z.objectUtil.extendShape<{
        type: z.ZodEnum<["function"]>;
        definition: z.ZodObject<{
            schema: z.ZodObject<{
                name: z.ZodString;
                description: z.ZodString;
                parameters: z.ZodAny;
                strict: z.ZodOptional<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }, {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            }>;
        }, "strip", z.ZodTypeAny, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }, {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        }>;
        request: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"http">;
            method: z.ZodEnum<["get", "post"]>;
            url: z.ZodString;
            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
            proxyUrl: z.ZodOptional<z.ZodString>;
            proxyHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
            retry: z.ZodOptional<z.ZodObject<{
                maxAttempts: z.ZodNumber;
                initialDelay: z.ZodNumber;
                exponentialFactor: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            }, {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            type: "http";
            url: string;
            method: "get" | "post";
            headers?: Record<string, string> | undefined;
            query?: Record<string, string> | undefined;
            body?: Record<string, any> | undefined;
            proxyUrl?: string | undefined;
            proxyHeaders?: Record<string, string> | undefined;
            retry?: {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            } | undefined;
        }, {
            type: "http";
            url: string;
            method: "get" | "post";
            headers?: Record<string, string> | undefined;
            query?: Record<string, string> | undefined;
            body?: Record<string, any> | undefined;
            proxyUrl?: string | undefined;
            proxyHeaders?: Record<string, string> | undefined;
            retry?: {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            } | undefined;
        }>]>>;
    }, {
        metadata: z.ZodTypeAny;
    }>, "strip", z.ZodTypeAny, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
        request?: {
            type: "http";
            url: string;
            method: "get" | "post";
            headers?: Record<string, string> | undefined;
            query?: Record<string, string> | undefined;
            body?: Record<string, any> | undefined;
            proxyUrl?: string | undefined;
            proxyHeaders?: Record<string, string> | undefined;
            retry?: {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            } | undefined;
        } | undefined;
    }, {
        type: "function";
        definition: {
            schema: {
                name: string;
                description: string;
                strict?: boolean | undefined;
                parameters?: any;
            };
        };
        metadata?: any;
        request?: {
            type: "http";
            url: string;
            method: "get" | "post";
            headers?: Record<string, string> | undefined;
            query?: Record<string, string> | undefined;
            body?: Record<string, any> | undefined;
            proxyUrl?: string | undefined;
            proxyHeaders?: Record<string, string> | undefined;
            retry?: {
                maxAttempts: number;
                initialDelay: number;
                exponentialFactor: number;
            } | undefined;
        } | undefined;
    }>]>, "many">>;
    enableCache: z.ZodBoolean;
    customHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    callbacks: z.ZodOptional<z.ZodArray<z.ZodType<CompleteChatCallbackType<any>, z.ZodTypeDef, CompleteChatCallbackType<any>>, "atleastone">>;
    metadataForCallbacks: z.ZodOptional<z.ZodAny>;
}, "strip", z.ZodTypeAny, {
    config: Record<string, any>;
    model: ChatModelV1<{
        name: string;
        description: string;
        roles: Partial<Record<"system" | "user" | "assistant" | "tool", string | undefined>>;
        modalities: ["text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning", ...("text" | "image" | "pdf" | "tool-call" | "tool-response" | "reasoning")[]];
        maxInputTokens: number;
        maxOutputTokens: number;
        config: {
            def: Record<string, {
                type: "multi-string";
                param: string;
                title: string;
                description: string;
                max: number;
            } | {
                type: "object-schema";
                param: string;
                title: string;
                description: string;
                objectSchema?: any;
            } | {
                type: "range";
                param: string;
                title: string;
                description: string;
                max: number;
                default: number;
                min: number;
                step: number;
            } | {
                type: "select-boolean";
                param: string;
                title: string;
                description: string;
                default: boolean | null;
            } | {
                type: "select-string";
                param: string;
                title: string;
                description: string;
                default: string;
                choices: string[];
            }>;
            schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, unknown, unknown>;
        };
        price: {
            modelName: string;
            currency: string;
            tokenRanges: {
                minTokens: number;
                prices: {
                    base: {
                        inputPricePerMillion: number;
                        outputPricePerMillion: number;
                    };
                };
                maxTokens?: number | null | undefined;
            }[];
        };
        maxReasoningTokens?: number | undefined;
    }>;
    messages: {
        role: "system" | "user" | "assistant" | "tool";
        content: ({
            modality: "tool-response";
            name: string;
            id: string;
            data: string;
            index: number;
            metadata?: any;
            apiResponse?: {
                statusCode: number;
            } | undefined;
        } | {
            value: string;
            modality: "text";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
                mediaType: "png" | "jpeg" | "webp" | "gif";
            } | {
                type: "url";
                url: string;
            };
            modality: "image";
            detail: "low" | "medium" | "high" | "auto";
            metadata?: undefined;
        } | {
            value: {
                type: "base64";
                base64: string;
            } | {
                type: "url";
                url: string;
            };
            modality: "pdf";
            file: {
                name: string;
                id: string;
                size?: number | undefined;
            };
            metadata?: undefined;
        } | {
            id: string;
            name: string;
            modality: "tool-call";
            index: number;
            arguments: string;
            metadata?: undefined;
        } | {
            value: {
                type: "thinking";
                thinking: string;
                signature: string;
            } | {
                type: "redacted";
                data: string;
            };
            modality: "reasoning";
            metadata?: undefined;
        })[];
        metadata?: undefined;
    }[];
    enableCache: boolean;
    cache: Cache<{
        request: {
            config: Record<string, any>;
            messages: {
                role: "system" | "user" | "assistant" | "tool";
                content: ({
                    modality: "tool-response";
                    name: string;
                    id: string;
                    data: string;
                    index: number;
                    metadata?: any;
                    apiResponse?: {
                        statusCode: number;
                    } | undefined;
                } | {
                    value: string;
                    modality: "text";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                        mediaType: "png" | "jpeg" | "webp" | "gif";
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "image";
                    detail: "low" | "medium" | "high" | "auto";
                    metadata?: undefined;
                } | {
                    value: {
                        type: "base64";
                        base64: string;
                    } | {
                        type: "url";
                        url: string;
                    };
                    modality: "pdf";
                    file: {
                        name: string;
                        id: string;
                        size?: number | undefined;
                    };
                    metadata?: undefined;
                } | {
                    id: string;
                    name: string;
                    modality: "tool-call";
                    index: number;
                    arguments: string;
                    metadata?: undefined;
                } | {
                    value: {
                        type: "thinking";
                        thinking: string;
                        signature: string;
                    } | {
                        type: "redacted";
                        data: string;
                    };
                    modality: "reasoning";
                    metadata?: undefined;
                })[];
                metadata?: undefined;
            }[];
            tools?: {
                type: "function";
                definition: {
                    schema: {
                        name: string;
                        description: string;
                        strict?: boolean | undefined;