import type { ZodType, ZodTypeDef } from "zod";
import type { Schema } from "ai";
import type { Tool, LanguageModel } from "ai";
import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
import type { JsonValue, UnknownRecord } from "../types/common.js";
import type { ToolResult } from "../types/tools.js";
/**
 * Interface for SDK with in-memory MCP servers
 */
export interface NeuroLinkSDK {
    getInMemoryServers?: () => Map<string, {
        server: {
            title?: string;
            description?: string;
            tools?: Map<string, ToolInfo> | Record<string, ToolInfo>;
        };
        category?: string;
        metadata?: UnknownRecord;
    }>;
}
/**
 * Interface for tool information in MCP servers
 */
interface ToolInfo {
    description?: string;
    inputSchema?: ZodType<JsonValue>;
    parameters?: ZodType<JsonValue>;
    execute: (args: JsonValue) => Promise<JsonValue | ToolResult> | JsonValue | ToolResult;
    isImplemented?: boolean;
    metadata?: UnknownRecord;
}
/**
 * Abstract base class for all AI providers
 * Tools are integrated as first-class citizens - always available by default
 */
export declare abstract class BaseProvider implements AIProvider {
    protected readonly modelName: string;
    protected readonly providerName: AIProviderName;
    protected readonly defaultTimeout: number;
    protected readonly directTools: {
        getCurrentTime: Tool<import("zod").ZodObject<{
            timezone: import("zod").ZodOptional<import("zod").ZodString>;
        }, "strip", import("zod").ZodTypeAny, {
            timezone?: string | undefined;
        }, {
            timezone?: string | undefined;
        }>, {
            success: boolean;
            time: string;
            timezone: string;
            iso: string;
            timestamp?: undefined;
            error?: undefined;
        } | {
            success: boolean;
            time: string;
            iso: string;
            timestamp: number;
            timezone?: undefined;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            time?: undefined;
            timezone?: undefined;
            iso?: undefined;
            timestamp?: undefined;
        }> & {
            execute: (args: {
                timezone?: string | undefined;
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                time: string;
                timezone: string;
                iso: string;
                timestamp?: undefined;
                error?: undefined;
            } | {
                success: boolean;
                time: string;
                iso: string;
                timestamp: number;
                timezone?: undefined;
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                time?: undefined;
                timezone?: undefined;
                iso?: undefined;
                timestamp?: undefined;
            }>;
        };
        readFile: Tool<import("zod").ZodObject<{
            path: import("zod").ZodString;
        }, "strip", import("zod").ZodTypeAny, {
            path: string;
        }, {
            path: string;
        }>, {
            success: boolean;
            error: string;
            content?: undefined;
            size?: undefined;
            path?: undefined;
            lastModified?: undefined;
        } | {
            success: boolean;
            content: string;
            size: number;
            path: string;
            lastModified: string;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            path: string;
            content?: undefined;
            size?: undefined;
            lastModified?: undefined;
        }> & {
            execute: (args: {
                path: string;
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                error: string;
                content?: undefined;
                size?: undefined;
                path?: undefined;
                lastModified?: undefined;
            } | {
                success: boolean;
                content: string;
                size: number;
                path: string;
                lastModified: string;
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                path: string;
                content?: undefined;
                size?: undefined;
                lastModified?: undefined;
            }>;
        };
        listDirectory: Tool<import("zod").ZodObject<{
            path: import("zod").ZodString;
            includeHidden: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
        }, "strip", import("zod").ZodTypeAny, {
            path: string;
            includeHidden: boolean;
        }, {
            path: string;
            includeHidden?: boolean | undefined;
        }>, {
            success: boolean;
            path: string;
            items: {
                name: string;
                type: string;
                size: number | undefined;
                lastModified: string;
            }[];
            count: number;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            path: string;
            items?: undefined;
            count?: undefined;
        }> & {
            execute: (args: {
                path: string;
                includeHidden: boolean;
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                path: string;
                items: {
                    name: string;
                    type: string;
                    size: number | undefined;
                    lastModified: string;
                }[];
                count: number;
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                path: string;
                items?: undefined;
                count?: undefined;
            }>;
        };
        calculateMath: Tool<import("zod").ZodObject<{
            expression: import("zod").ZodString;
            precision: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
        }, "strip", import("zod").ZodTypeAny, {
            expression: string;
            precision: number;
        }, {
            expression: string;
            precision?: number | undefined;
        }>, {
            success: boolean;
            error: string;
            expression?: undefined;
            result?: undefined;
            type?: undefined;
        } | {
            success: boolean;
            expression: string;
            result: any;
            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            expression: string;
            result?: undefined;
            type?: undefined;
        }> & {
            execute: (args: {
                expression: string;
                precision: number;
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                error: string;
                expression?: undefined;
                result?: undefined;
                type?: undefined;
            } | {
                success: boolean;
                expression: string;
                result: any;
                type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                expression: string;
                result?: undefined;
                type?: undefined;
            }>;
        };
        writeFile: Tool<import("zod").ZodObject<{
            path: import("zod").ZodString;
            content: import("zod").ZodString;
            mode: import("zod").ZodDefault<import("zod").ZodEnum<["create", "overwrite", "append"]>>;
        }, "strip", import("zod").ZodTypeAny, {
            path: string;
            content: string;
            mode: "create" | "overwrite" | "append";
        }, {
            path: string;
            content: string;
            mode?: "create" | "overwrite" | "append" | undefined;
        }>, {
            success: boolean;
            error: string;
            path?: undefined;
            mode?: undefined;
            size?: undefined;
            written?: undefined;
        } | {
            success: boolean;
            path: string;
            mode: "create" | "overwrite" | "append";
            size: number;
            written: number;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            path: string;
            mode?: undefined;
            size?: undefined;
            written?: undefined;
        }> & {
            execute: (args: {
                path: string;
                content: string;
                mode: "create" | "overwrite" | "append";
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                error: string;
                path?: undefined;
                mode?: undefined;
                size?: undefined;
                written?: undefined;
            } | {
                success: boolean;
                path: string;
                mode: "create" | "overwrite" | "append";
                size: number;
                written: number;
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                path: string;
                mode?: undefined;
                size?: undefined;
                written?: undefined;
            }>;
        };
        searchFiles: Tool<import("zod").ZodObject<{
            directory: import("zod").ZodString;
            pattern: import("zod").ZodString;
            recursive: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
        }, "strip", import("zod").ZodTypeAny, {
            directory: string;
            pattern: string;
            recursive: boolean;
        }, {
            directory: string;
            pattern: string;
            recursive?: boolean | undefined;
        }>, {
            success: boolean;
            error: string;
            directory?: undefined;
            pattern?: undefined;
            matches?: undefined;
            count?: undefined;
        } | {
            success: boolean;
            directory: string;
            pattern: string;
            matches: {
                name: string;
                path: string;
                size: number;
                lastModified: string;
            }[];
            count: number;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            directory: string;
            pattern: string;
            matches?: undefined;
            count?: undefined;
        }> & {
            execute: (args: {
                directory: string;
                pattern: string;
                recursive: boolean;
            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
                success: boolean;
                error: string;
                directory?: undefined;
                pattern?: undefined;
                matches?: undefined;
                count?: undefined;
            } | {
                success: boolean;
                directory: string;
                pattern: string;
                matches: {
                    name: string;
                    path: string;
                    size: number;
                    lastModified: string;
                }[];
                count: number;
                error?: undefined;
            } | {
                success: boolean;
                error: string;
                directory: string;
                pattern: string;
                matches?: undefined;
                count?: undefined;
            }>;
        };
    };
    protected mcpTools?: Record<string, Tool>;
    protected sessionId?: string;
    protected userId?: string;
    protected sdk?: NeuroLinkSDK;
    constructor(modelName?: string, providerName?: AIProviderName, sdk?: NeuroLinkSDK);
    /**
     * Check if this provider supports tool/function calling
     * Override in subclasses to disable tools for specific providers or models
     * @returns true by default, providers can override to return false
     */
    supportsTools(): boolean;
    /**
     * Primary streaming method - implements AIProvider interface
     * When tools are involved, falls back to generate() with synthetic streaming
     */
    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
    /**
     * Text generation method - implements AIProvider interface
     * Tools are always available unless explicitly disabled
     */
    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
    /**
     * Alias for generate method - implements AIProvider interface
     */
    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
    /**
     * Provider-specific streaming implementation (only used when tools are disabled)
     */
    protected abstract executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
    /**
     * Get the provider name
     */
    protected abstract getProviderName(): AIProviderName;
    /**
     * Get the default model for this provider
     */
    protected abstract getDefaultModel(): string;
    /**
     * REQUIRED: Every provider MUST implement this method
     * Returns the Vercel AI SDK model instance for this provider
     */
    protected abstract getAISDKModel(): LanguageModel | Promise<LanguageModel>;
    /**
     * Get all available tools - direct tools are ALWAYS available
     * MCP tools are added when available (without blocking)
     */
    protected getAllTools(): Promise<Record<string, Tool>>;
    /**
     * Set session context for MCP tools
     */
    setSessionContext(sessionId?: string, userId?: string): void;
    /**
     * Provider-specific error handling
     */
    protected abstract handleProviderError(error: unknown): Error;
    protected normalizeTextOptions(optionsOrPrompt: TextGenerationOptions | string): TextGenerationOptions;
    protected normalizeStreamOptions(optionsOrPrompt: StreamOptions | string): StreamOptions;
    protected enhanceResult(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
    protected createAnalytics(result: EnhancedGenerateResult, responseTime: number, options: TextGenerationOptions): Promise<AnalyticsData>;
    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<EvaluationData>;
    protected validateOptions(options: TextGenerationOptions): void;
    protected getProviderInfo(): {
        provider: string;
        model: string;
    };
    /**
     * Get timeout value in milliseconds
     */
    getTimeout(options: TextGenerationOptions | StreamOptions): number;
    /**
     * Utility method to chunk large prompts into smaller pieces
     * @param prompt The prompt to chunk
     * @param maxChunkSize Maximum size per chunk (default: 900,000 characters)
     * @param overlap Overlap between chunks to maintain context (default: 100 characters)
     * @returns Array of prompt chunks
     */
    static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
}
export {};