@easbot/llm 0.3.19

package/dist/index.d.ts

@@ -0,0 +1,1903 @@
+import * as _ai_sdk_provider from '@ai-sdk/provider';
+import { JSONSchema7, LanguageModelV3 } from '@ai-sdk/provider';
+import z from 'zod';
+import { LanguageModel, EmbeddingModel, RerankingModel, APICallError, ModelMessage } from 'ai';
+import { JSONSchema } from 'zod/v4/core';
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+declare namespace ModelsDev {
+    const Model: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        family: z.ZodOptional<z.ZodString>;
+        release_date: z.ZodString;
+        attachment: z.ZodBoolean;
+        reasoning: z.ZodBoolean;
+        temperature: z.ZodBoolean;
+        tool_call: z.ZodBoolean;
+        interleaved: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            field: z.ZodEnum<{
+                reasoning_content: "reasoning_content";
+                reasoning_details: "reasoning_details";
+            }>;
+        }, z.core.$strict>]>>;
+        cost: z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cache_read: z.ZodOptional<z.ZodNumber>;
+            cache_write: z.ZodOptional<z.ZodNumber>;
+            context_over_200k: z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache_read: z.ZodOptional<z.ZodNumber>;
+                cache_write: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        limit: z.ZodObject<{
+            context: z.ZodNumber;
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+        modalities: z.ZodOptional<z.ZodObject<{
+            input: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                pdf: "pdf";
+            }>>;
+            output: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                pdf: "pdf";
+            }>>;
+        }, z.core.$strip>>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+        status: z.ZodOptional<z.ZodEnum<{
+            alpha: "alpha";
+            beta: "beta";
+            deprecated: "deprecated";
+        }>>;
+        options: z.ZodRecord<z.ZodString, z.ZodAny>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        provider: z.ZodOptional<z.ZodObject<{
+            npm: z.ZodString;
+        }, z.core.$strip>>;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>;
+    type Model = z.infer<typeof Model>;
+    const Provider: z.ZodObject<{
+        api: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        env: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        npm: z.ZodOptional<z.ZodString>;
+        models: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            family: z.ZodOptional<z.ZodString>;
+            release_date: z.ZodString;
+            attachment: z.ZodBoolean;
+            reasoning: z.ZodBoolean;
+            temperature: z.ZodBoolean;
+            tool_call: z.ZodBoolean;
+            interleaved: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                field: z.ZodEnum<{
+                    reasoning_content: "reasoning_content";
+                    reasoning_details: "reasoning_details";
+                }>;
+            }, z.core.$strict>]>>;
+            cost: z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache_read: z.ZodOptional<z.ZodNumber>;
+                cache_write: z.ZodOptional<z.ZodNumber>;
+                context_over_200k: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cache_read: z.ZodOptional<z.ZodNumber>;
+                    cache_write: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            limit: z.ZodObject<{
+                context: z.ZodNumber;
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodNumber;
+            }, z.core.$strip>;
+            modalities: z.ZodOptional<z.ZodObject<{
+                input: z.ZodArray<z.ZodEnum<{
+                    text: "text";
+                    audio: "audio";
+                    image: "image";
+                    video: "video";
+                    pdf: "pdf";
+                }>>;
+                output: z.ZodArray<z.ZodEnum<{
+                    text: "text";
+                    audio: "audio";
+                    image: "image";
+                    video: "video";
+                    pdf: "pdf";
+                }>>;
+            }, z.core.$strip>>;
+            experimental: z.ZodOptional<z.ZodBoolean>;
+            status: z.ZodOptional<z.ZodEnum<{
+                alpha: "alpha";
+                beta: "beta";
+                deprecated: "deprecated";
+            }>>;
+            options: z.ZodRecord<z.ZodString, z.ZodAny>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            provider: z.ZodOptional<z.ZodObject<{
+                npm: z.ZodString;
+            }, z.core.$strip>>;
+            variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    type Provider = z.infer<typeof Provider>;
+    const Data: {
+        (): Promise<Record<string, {
+            name: string;
+            env: string[];
+            id: string;
+            models: Record<string, {
+                id: string;
+                name: string;
+                release_date: string;
+                attachment: boolean;
+                reasoning: boolean;
+                temperature: boolean;
+                tool_call: boolean;
+                limit: {
+                    context: number;
+                    output: number;
+                    input?: number | undefined;
+                };
+                options: Record<string, any>;
+                family?: string | undefined;
+                interleaved?: true | {
+                    field: "reasoning_content" | "reasoning_details";
+                } | undefined;
+                cost?: {
+                    input: number;
+                    output: number;
+                    cache_read?: number | undefined;
+                    cache_write?: number | undefined;
+                    context_over_200k?: {
+                        input: number;
+                        output: number;
+                        cache_read?: number | undefined;
+                        cache_write?: number | undefined;
+                    } | undefined;
+                } | undefined;
+                modalities?: {
+                    input: ("text" | "audio" | "image" | "video" | "pdf")[];
+                    output: ("text" | "audio" | "image" | "video" | "pdf")[];
+                } | undefined;
+                experimental?: boolean | undefined;
+                status?: "alpha" | "beta" | "deprecated" | undefined;
+                headers?: Record<string, string> | undefined;
+                provider?: {
+                    npm: string;
+                } | undefined;
+                variants?: Record<string, Record<string, any>> | undefined;
+            }>;
+            api?: string | undefined;
+            npm?: string | undefined;
+        }>>;
+        reset(): void;
+    };
+    function get(): Promise<Record<string, {
+        name: string;
+        env: string[];
+        id: string;
+        models: Record<string, {
+            id: string;
+            name: string;
+            release_date: string;
+            attachment: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            tool_call: boolean;
+            limit: {
+                context: number;
+                output: number;
+                input?: number | undefined;
+            };
+            options: Record<string, any>;
+            family?: string | undefined;
+            interleaved?: true | {
+                field: "reasoning_content" | "reasoning_details";
+            } | undefined;
+            cost?: {
+                input: number;
+                output: number;
+                cache_read?: number | undefined;
+                cache_write?: number | undefined;
+                context_over_200k?: {
+                    input: number;
+                    output: number;
+                    cache_read?: number | undefined;
+                    cache_write?: number | undefined;
+                } | undefined;
+            } | undefined;
+            modalities?: {
+                input: ("text" | "audio" | "image" | "video" | "pdf")[];
+                output: ("text" | "audio" | "image" | "video" | "pdf")[];
+            } | undefined;
+            experimental?: boolean | undefined;
+            status?: "alpha" | "beta" | "deprecated" | undefined;
+            headers?: Record<string, string> | undefined;
+            provider?: {
+                npm: string;
+            } | undefined;
+            variants?: Record<string, Record<string, any>> | undefined;
+        }>;
+        api?: string | undefined;
+        npm?: string | undefined;
+    }>>;
+    function refresh(): Promise<void>;
+}
+declare function initModelsRefresh(): void;
+
+declare namespace Provider {
+    function registerPluginAuthLoader(entry: {
+        providerId: string;
+        authProvider: string;
+        loader: (getAuth: () => Promise<any>, authProviderData: any) => Promise<any>;
+    }): void;
+    function clearPluginAuthLoaders(): void;
+    const DEFAULT_CONTEXT_LIMIT = 200000;
+    const DEFAULT_INPUT_LIMIT_RATIO = 0.9;
+    const DEFAULT_OUTPUT_LIMIT = 8192;
+    function getDefaultInputLimit(contextLimit?: number): number;
+    const Model: z.ZodObject<{
+        id: z.ZodString;
+        providerId: z.ZodString;
+        api: z.ZodObject<{
+            id: z.ZodString;
+            url: z.ZodString;
+            npm: z.ZodString;
+        }, z.core.$strip>;
+        name: z.ZodString;
+        family: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodObject<{
+            temperature: z.ZodBoolean;
+            reasoning: z.ZodBoolean;
+            attachment: z.ZodBoolean;
+            toolcall: z.ZodBoolean;
+            input: z.ZodObject<{
+                text: z.ZodBoolean;
+                audio: z.ZodBoolean;
+                image: z.ZodBoolean;
+                video: z.ZodBoolean;
+                pdf: z.ZodBoolean;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                text: z.ZodBoolean;
+                audio: z.ZodBoolean;
+                image: z.ZodBoolean;
+                video: z.ZodBoolean;
+                pdf: z.ZodBoolean;
+            }, z.core.$strip>;
+            interleaved: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                field: z.ZodEnum<{
+                    reasoning_content: "reasoning_content";
+                    reasoning_details: "reasoning_details";
+                }>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>;
+        cost: z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cache: z.ZodObject<{
+                read: z.ZodNumber;
+                write: z.ZodNumber;
+            }, z.core.$strip>;
+            experimentalOver200K: z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache: z.ZodObject<{
+                    read: z.ZodNumber;
+                    write: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        limit: z.ZodObject<{
+            context: z.ZodNumber;
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+        status: z.ZodEnum<{
+            alpha: "alpha";
+            beta: "beta";
+            deprecated: "deprecated";
+            active: "active";
+        }>;
+        options: z.ZodRecord<z.ZodString, z.ZodAny>;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        release_date: z.ZodString;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>;
+    type Model = z.infer<typeof Model>;
+    const Info: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodEnum<{
+            api: "api";
+            env: "env";
+            custom: "custom";
+            config: "config";
+        }>;
+        env: z.ZodArray<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        options: z.ZodRecord<z.ZodString, z.ZodAny>;
+        models: z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodString;
+            providerId: z.ZodString;
+            api: z.ZodObject<{
+                id: z.ZodString;
+                url: z.ZodString;
+                npm: z.ZodString;
+            }, z.core.$strip>;
+            name: z.ZodString;
+            family: z.ZodOptional<z.ZodString>;
+            capabilities: z.ZodObject<{
+                temperature: z.ZodBoolean;
+                reasoning: z.ZodBoolean;
+                attachment: z.ZodBoolean;
+                toolcall: z.ZodBoolean;
+                input: z.ZodObject<{
+                    text: z.ZodBoolean;
+                    audio: z.ZodBoolean;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    pdf: z.ZodBoolean;
+                }, z.core.$strip>;
+                output: z.ZodObject<{
+                    text: z.ZodBoolean;
+                    audio: z.ZodBoolean;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    pdf: z.ZodBoolean;
+                }, z.core.$strip>;
+                interleaved: z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+                    field: z.ZodEnum<{
+                        reasoning_content: "reasoning_content";
+                        reasoning_details: "reasoning_details";
+                    }>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>;
+            cost: z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache: z.ZodObject<{
+                    read: z.ZodNumber;
+                    write: z.ZodNumber;
+                }, z.core.$strip>;
+                experimentalOver200K: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cache: z.ZodObject<{
+                        read: z.ZodNumber;
+                        write: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            limit: z.ZodObject<{
+                context: z.ZodNumber;
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodNumber;
+            }, z.core.$strip>;
+            status: z.ZodEnum<{
+                alpha: "alpha";
+                beta: "beta";
+                deprecated: "deprecated";
+                active: "active";
+            }>;
+            options: z.ZodRecord<z.ZodString, z.ZodAny>;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            release_date: z.ZodString;
+            variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    type Info = z.infer<typeof Info>;
+    function fromModelsDevProvider(provider: ModelsDev.Provider): Info;
+    function resetState(): void;
+    function list(): Promise<{
+        [providerId: string]: {
+            id: string;
+            name: string;
+            source: "api" | "env" | "custom" | "config";
+            env: string[];
+            options: Record<string, any>;
+            models: Record<string, {
+                id: string;
+                providerId: string;
+                api: {
+                    id: string;
+                    url: string;
+                    npm: string;
+                };
+                name: string;
+                capabilities: {
+                    temperature: boolean;
+                    reasoning: boolean;
+                    attachment: boolean;
+                    toolcall: boolean;
+                    input: {
+                        text: boolean;
+                        audio: boolean;
+                        image: boolean;
+                        video: boolean;
+                        pdf: boolean;
+                    };
+                    output: {
+                        text: boolean;
+                        audio: boolean;
+                        image: boolean;
+                        video: boolean;
+                        pdf: boolean;
+                    };
+                    interleaved: boolean | {
+                        field: "reasoning_content" | "reasoning_details";
+                    };
+                };
+                cost: {
+                    input: number;
+                    output: number;
+                    cache: {
+                        read: number;
+                        write: number;
+                    };
+                    experimentalOver200K?: {
+                        input: number;
+                        output: number;
+                        cache: {
+                            read: number;
+                            write: number;
+                        };
+                    } | undefined;
+                };
+                limit: {
+                    context: number;
+                    output: number;
+                    input?: number | undefined;
+                };
+                status: "alpha" | "beta" | "deprecated" | "active";
+                options: Record<string, any>;
+                headers: Record<string, string>;
+                release_date: string;
+                family?: string | undefined;
+                variants?: Record<string, Record<string, any>> | undefined;
+            }>;
+            key?: string | undefined;
+        };
+    }>;
+    function getLocalProxy(): Promise<Map<string, string | _ai_sdk_provider.LanguageModelV3 | (string & {}) | _ai_sdk_provider.LanguageModelV2 | _ai_sdk_provider.EmbeddingModelV3 | _ai_sdk_provider.EmbeddingModelV2<string> | _ai_sdk_provider.RerankingModelV3>>;
+    function getProvider(providerId: string): Promise<{
+        id: string;
+        name: string;
+        source: "api" | "env" | "custom" | "config";
+        env: string[];
+        options: Record<string, any>;
+        models: Record<string, {
+            id: string;
+            providerId: string;
+            api: {
+                id: string;
+                url: string;
+                npm: string;
+            };
+            name: string;
+            capabilities: {
+                temperature: boolean;
+                reasoning: boolean;
+                attachment: boolean;
+                toolcall: boolean;
+                input: {
+                    text: boolean;
+                    audio: boolean;
+                    image: boolean;
+                    video: boolean;
+                    pdf: boolean;
+                };
+                output: {
+                    text: boolean;
+                    audio: boolean;
+                    image: boolean;
+                    video: boolean;
+                    pdf: boolean;
+                };
+                interleaved: boolean | {
+                    field: "reasoning_content" | "reasoning_details";
+                };
+            };
+            cost: {
+                input: number;
+                output: number;
+                cache: {
+                    read: number;
+                    write: number;
+                };
+                experimentalOver200K?: {
+                    input: number;
+                    output: number;
+                    cache: {
+                        read: number;
+                        write: number;
+                    };
+                } | undefined;
+            };
+            limit: {
+                context: number;
+                output: number;
+                input?: number | undefined;
+            };
+            status: "alpha" | "beta" | "deprecated" | "active";
+            options: Record<string, any>;
+            headers: Record<string, string>;
+            release_date: string;
+            family?: string | undefined;
+            variants?: Record<string, Record<string, any>> | undefined;
+        }>;
+        key?: string | undefined;
+    } | undefined>;
+    function getModel(providerId: string, modelId: string): Promise<{
+        id: string;
+        providerId: string;
+        api: {
+            id: string;
+            url: string;
+            npm: string;
+        };
+        name: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            attachment: boolean;
+            toolcall: boolean;
+            input: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            output: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            interleaved: boolean | {
+                field: "reasoning_content" | "reasoning_details";
+            };
+        };
+        cost: {
+            input: number;
+            output: number;
+            cache: {
+                read: number;
+                write: number;
+            };
+            experimentalOver200K?: {
+                input: number;
+                output: number;
+                cache: {
+                    read: number;
+                    write: number;
+                };
+            } | undefined;
+        };
+        limit: {
+            context: number;
+            output: number;
+            input?: number | undefined;
+        };
+        status: "alpha" | "beta" | "deprecated" | "active";
+        options: Record<string, any>;
+        headers: Record<string, string>;
+        release_date: string;
+        family?: string | undefined;
+        variants?: Record<string, Record<string, any>> | undefined;
+    }>;
+    function getLanguage(model: Model): Promise<LanguageModel>;
+    function getEmbedding(providerId: string, modelId: string): Promise<EmbeddingModel>;
+    function getRerank(providerId: string, modelId: string): Promise<RerankingModel>;
+    function closest(providerId: string, query: string[]): Promise<{
+        providerId: string;
+        modelId: string;
+    } | undefined>;
+    function getSmallModel(providerId: string): Promise<{
+        id: string;
+        providerId: string;
+        api: {
+            id: string;
+            url: string;
+            npm: string;
+        };
+        name: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            attachment: boolean;
+            toolcall: boolean;
+            input: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            output: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            interleaved: boolean | {
+                field: "reasoning_content" | "reasoning_details";
+            };
+        };
+        cost: {
+            input: number;
+            output: number;
+            cache: {
+                read: number;
+                write: number;
+            };
+            experimentalOver200K?: {
+                input: number;
+                output: number;
+                cache: {
+                    read: number;
+                    write: number;
+                };
+            } | undefined;
+        };
+        limit: {
+            context: number;
+            output: number;
+            input?: number | undefined;
+        };
+        status: "alpha" | "beta" | "deprecated" | "active";
+        options: Record<string, any>;
+        headers: Record<string, string>;
+        release_date: string;
+        family?: string | undefined;
+        variants?: Record<string, Record<string, any>> | undefined;
+    } | undefined>;
+    function sort(models: Model[]): {
+        id: string;
+        providerId: string;
+        api: {
+            id: string;
+            url: string;
+            npm: string;
+        };
+        name: string;
+        capabilities: {
+            temperature: boolean;
+            reasoning: boolean;
+            attachment: boolean;
+            toolcall: boolean;
+            input: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            output: {
+                text: boolean;
+                audio: boolean;
+                image: boolean;
+                video: boolean;
+                pdf: boolean;
+            };
+            interleaved: boolean | {
+                field: "reasoning_content" | "reasoning_details";
+            };
+        };
+        cost: {
+            input: number;
+            output: number;
+            cache: {
+                read: number;
+                write: number;
+            };
+            experimentalOver200K?: {
+                input: number;
+                output: number;
+                cache: {
+                    read: number;
+                    write: number;
+                };
+            } | undefined;
+        };
+        limit: {
+            context: number;
+            output: number;
+            input?: number | undefined;
+        };
+        status: "alpha" | "beta" | "deprecated" | "active";
+        options: Record<string, any>;
+        headers: Record<string, string>;
+        release_date: string;
+        family?: string | undefined;
+        variants?: Record<string, Record<string, any>> | undefined;
+    }[];
+    function defaultModel(): Promise<{
+        providerId: string;
+        modelId: string;
+    }>;
+    function parseModel(model: string): {
+        providerId: string;
+        modelId: string;
+    };
+    const ModelNotFoundError: {
+        new (data: {
+            providerId: string;
+            modelId: string;
+            suggestions?: string[] | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "ProviderModelNotFoundError";
+            readonly data: {
+                providerId: string;
+                modelId: string;
+                suggestions?: string[] | undefined;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderModelNotFoundError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                    suggestions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "ProviderModelNotFoundError";
+                data: {
+                    providerId: string;
+                    modelId: string;
+                    suggestions?: string[] | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderModelNotFoundError">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                suggestions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    const InitError: {
+        new (data: {
+            providerId: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ProviderInitError";
+            readonly data: {
+                providerId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderInitError">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "ProviderInitError";
+                data: {
+                    providerId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderInitError">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}
+
+declare namespace ProviderError {
+    type ParsedStreamError = {
+        type: 'context_overflow';
+        message: string;
+        responseBody: string;
+    } | {
+        type: 'api_error';
+        message: string;
+        isRetryable: boolean;
+        responseBody: string;
+    };
+    function parseStreamError(input: unknown): ParsedStreamError | undefined;
+    type ParsedAPICallError = {
+        type: 'context_overflow';
+        message: string;
+        responseBody?: string;
+    } | {
+        type: 'api_error';
+        message: string;
+        statusCode?: number;
+        isRetryable: boolean;
+        responseHeaders?: Record<string, string>;
+        responseBody?: string;
+        metadata?: Record<string, string>;
+    };
+    function parseAPICallError(input: {
+        providerId: string;
+        error: APICallError;
+    }): ParsedAPICallError;
+}
+
+declare namespace ProviderAuth {
+    function registerPluginAuthProvider(entry: {
+        providerId: string;
+        methods: Array<{
+            type: 'oauth' | 'api';
+            label: string;
+            [key: string]: any;
+        }>;
+    }): void;
+    function clearPluginAuthProviders(): void;
+    function resetState(): void;
+    const Method: z.ZodObject<{
+        type: z.ZodUnion<readonly [z.ZodLiteral<"oauth">, z.ZodLiteral<"api">]>;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    type Method = z.infer<typeof Method>;
+    function methods(): Promise<{
+        [x: string]: any;
+    }>;
+    const Authorization: z.ZodObject<{
+        url: z.ZodString;
+        method: z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodLiteral<"code">]>;
+        instructions: z.ZodString;
+    }, z.core.$strip>;
+    type Authorization = z.infer<typeof Authorization>;
+    const authorize: {
+        (input: {
+            providerId: string;
+            method: number;
+        }): Promise<{
+            url: string;
+            method: "auto" | "code";
+            instructions: string;
+        } | undefined>;
+        force(input: {
+            providerId: string;
+            method: number;
+        }): Promise<{
+            url: string;
+            method: "auto" | "code";
+            instructions: string;
+        } | undefined>;
+        schema: z.ZodObject<{
+            providerId: z.ZodString;
+            method: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    const callback: {
+        (input: {
+            providerId: string;
+            method: number;
+            code?: string | undefined;
+        }): Promise<void>;
+        force(input: {
+            providerId: string;
+            method: number;
+            code?: string | undefined;
+        }): Promise<void>;
+        schema: z.ZodObject<{
+            providerId: z.ZodString;
+            method: z.ZodNumber;
+            code: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    const api: {
+        (input: {
+            providerId: string;
+            key: string;
+        }): Promise<void>;
+        force(input: {
+            providerId: string;
+            key: string;
+        }): Promise<void>;
+        schema: z.ZodObject<{
+            providerId: z.ZodString;
+            key: z.ZodString;
+        }, z.core.$strip>;
+    };
+    const OauthMissing: {
+        new (data: {
+            providerId: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ProviderAuthOauthMissing";
+            readonly data: {
+                providerId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderAuthOauthMissing">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "ProviderAuthOauthMissing";
+                data: {
+                    providerId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderAuthOauthMissing">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    const OauthCodeMissing: {
+        new (data: {
+            providerId: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ProviderAuthOauthCodeMissing";
+            readonly data: {
+                providerId: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderAuthOauthCodeMissing">;
+                data: z.ZodObject<{
+                    providerId: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "ProviderAuthOauthCodeMissing";
+                data: {
+                    providerId: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderAuthOauthCodeMissing">;
+            data: z.ZodObject<{
+                providerId: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    const OauthCallbackFailed: {
+        new (data: Record<string, never>, options?: ErrorOptions): {
+            readonly name: "ProviderAuthOauthCallbackFailed";
+            readonly data: Record<string, never>;
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"ProviderAuthOauthCallbackFailed">;
+                data: z.ZodObject<{}, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "ProviderAuthOauthCallbackFailed";
+                data: Record<string, never>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"ProviderAuthOauthCallbackFailed">;
+            data: z.ZodObject<{}, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType<any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}
+
+declare namespace ProviderTransform {
+    function getOutputTokenMax(): number;
+    function message(msgs: ModelMessage[], model: Provider.Model, options: Record<string, unknown>): ModelMessage[];
+    function temperature(model: Provider.Model): 1 | 0.6 | 0.55 | undefined;
+    function topP(model: Provider.Model): 1 | 0.95 | undefined;
+    function topK(model: Provider.Model): 20 | 40 | 64 | undefined;
+    function variants(model: Provider.Model): Record<string, Record<string, any>>;
+    function options(input: {
+        model: Provider.Model;
+        sessionId: string;
+        providerOptions?: Record<string, any>;
+    }): Record<string, any>;
+    function smallOptions(model: Provider.Model): {
+        store: boolean;
+        reasoningEffort: string;
+        thinkingConfig?: undefined;
+        reasoning?: undefined;
+    } | {
+        store: boolean;
+        reasoningEffort?: undefined;
+        thinkingConfig?: undefined;
+        reasoning?: undefined;
+    } | {
+        thinkingConfig: {
+            thinkingLevel: string;
+            thinkingBudget?: undefined;
+        };
+        store?: undefined;
+        reasoningEffort?: undefined;
+        reasoning?: undefined;
+    } | {
+        thinkingConfig: {
+            thinkingBudget: number;
+            thinkingLevel?: undefined;
+        };
+        store?: undefined;
+        reasoningEffort?: undefined;
+        reasoning?: undefined;
+    } | {
+        reasoning: {
+            enabled: boolean;
+        };
+        store?: undefined;
+        reasoningEffort?: undefined;
+        thinkingConfig?: undefined;
+    } | {
+        reasoningEffort: string;
+        store?: undefined;
+        thinkingConfig?: undefined;
+        reasoning?: undefined;
+    } | {
+        store?: undefined;
+        reasoningEffort?: undefined;
+        thinkingConfig?: undefined;
+        reasoning?: undefined;
+    };
+    function providerOptions(model: Provider.Model, options: {
+        [x: string]: any;
+    }): Record<string, any>;
+    function maxOutputTokens(model: Provider.Model): number;
+    function schema(model: Provider.Model, schema: JSONSchema.BaseSchema | JSONSchema7): JSONSchema7;
+}
+
+declare const DEFAULT_ENABLED_PROVIDERS: readonly string[];
+declare const CUSTOM_PROVIDER_DEFINITIONS: Record<string, ModelsDev.Provider>;
+declare const PROVIDER_DISPLAY_NAMES: Record<string, string>;
+
+type OpenaiCompatibleModelId = string;
+interface OpenaiCompatibleProviderSettings {
+    apiKey?: string;
+    baseURL?: string;
+    name?: string;
+    headers?: Record<string, string>;
+    fetch?: FetchFunction;
+}
+interface OpenaiCompatibleProvider {
+    (modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    chat(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    responses(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+    languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+}
+declare function createOpenaiCompatible(options?: OpenaiCompatibleProviderSettings): OpenaiCompatibleProvider;
+declare const openaiCompatible: OpenaiCompatibleProvider;
+
+declare namespace RerankProvider {
+    type RerankInput = {
+        query: string;
+        documents: string[];
+        model?: Provider.Model | RerankingModel;
+        topN?: number;
+        abortSignal?: AbortSignal;
+    };
+    type RerankResult = {
+        index: number;
+        document: string;
+        score: number;
+        reason?: string;
+    };
+    function rerankDocuments(input: RerankInput, abortSignal?: AbortSignal): Promise<RerankResult[]>;
+}
+
+declare function inferEntityType(name: string): string;
+declare function sanitizeEntityToken(value: string): string;
+
+interface GraphEntityTypeDef {
+    readonly type: string;
+    readonly rule: string;
+}
+interface GraphRelationTypeDef {
+    readonly type: string;
+    readonly rule: string;
+}
+interface ExtractedEntity {
+    name: string;
+    type: string;
+    properties?: Record<string, unknown>;
+}
+interface ExtractedRelation {
+    source: string;
+    target: string;
+    relation: string;
+}
+interface ExtractionResult {
+    summary: string;
+    entities: ExtractedEntity[];
+    relations: ExtractedRelation[];
+}
+
+declare function extractEntitiesByRules(content: string): ExtractionResult;
+
+interface BuildPromptOptions {
+    maxContentLength?: number;
+    maxChunks?: number;
+    includeSummary?: boolean;
+}
+declare function buildEntityExtractionPrompt(chunks: string[], entityTypes: ReadonlyArray<GraphEntityTypeDef>, relationTypes: ReadonlyArray<GraphRelationTypeDef>, options?: BuildPromptOptions): string;
+
+declare function parseEntityExtractionResult(text: string, allowedEntities: ReadonlyArray<GraphEntityTypeDef>, allowedRelations: ReadonlyArray<GraphRelationTypeDef>): ExtractionResult;
+declare function normalizeExtractionResult(input: unknown, allowedEntities: ReadonlyArray<GraphEntityTypeDef>, allowedRelations: ReadonlyArray<GraphRelationTypeDef>): ExtractionResult;
+
+declare namespace GraphProvider {
+    interface GraphInput {
+        text?: string;
+        chunks?: ReadonlyArray<string>;
+        model?: Provider.Model | LanguageModel;
+        maxEntities?: number;
+        includeRules?: boolean;
+        abortSignal?: AbortSignal;
+        maxOutputTokens?: number;
+        prompt?: BuildPromptOptions & {
+            maxConcurrency?: number;
+        };
+        promptOverride?: string;
+    }
+    function generateGraph(input: GraphInput, abortSignal?: AbortSignal): Promise<ExtractionResult>;
+}
+
+declare namespace SummaryProvider {
+    type NoteSummaryInput = {
+        query: string;
+        chunks: Array<{
+            path: string;
+            content: string;
+            startLine?: number;
+            endLine?: number;
+            score?: number;
+            updatedAt?: number;
+            nodes?: Array<{
+                id: number;
+                name: string;
+                type: string;
+                properties?: Record<string, unknown>;
+                edges?: Array<{
+                    direction: 'out' | 'in';
+                    relation: string;
+                    targetId?: number;
+                    targetName: string;
+                    targetType: string;
+                }>;
+            }>;
+        }>;
+        model?: Provider.Model | LanguageModel;
+        maxLength?: number;
+        abortSignal?: AbortSignal;
+    };
+    type MemorySummaryInput = {
+        query: string;
+        facts: Array<{
+            content: string;
+            category: string;
+            importance: number;
+            source: string;
+            score?: number;
+            createdAt?: string;
+            nodes?: Array<{
+                id: number;
+                name: string;
+                type: string;
+                edges?: Array<{
+                    source: number;
+                    target: number;
+                    relation: string;
+                    direction?: 'in' | 'out';
+                    targetNode?: {
+                        name: string;
+                        type: string;
+                    };
+                }>;
+            }>;
+        }>;
+        model?: Provider.Model | LanguageModel;
+        maxLength?: number;
+        abortSignal?: AbortSignal;
+    };
+    function summarizeNote(input: NoteSummaryInput, abortSignal?: AbortSignal): Promise<string>;
+    function summarizeMemoryFacts(input: MemorySummaryInput, abortSignal?: AbortSignal): Promise<string>;
+}
+
+declare namespace EmbeddingProvider {
+    type EmbedInput = {
+        value: string;
+        model?: Provider.Model | EmbeddingModel;
+        abortSignal?: AbortSignal;
+    };
+    type EmbedBatchInput = {
+        values: string[];
+        model?: Provider.Model | EmbeddingModel;
+        abortSignal?: AbortSignal;
+    };
+    type EmbedOutput = {
+        embedding: number[];
+        usage: {
+            tokens: number;
+        };
+    };
+    type EmbedBatchOutput = {
+        embeddings: number[][];
+        usage: {
+            tokens: number;
+        };
+    };
+    const DEFAULT_MODEL = "easbot-local/bge-base-zh-v1.5";
+    function embedText(input: EmbedInput, abortSignal?: AbortSignal): Promise<EmbedOutput>;
+    function embedTexts(inputs: EmbedBatchInput, abortSignal?: AbortSignal): Promise<EmbedBatchOutput>;
+    function cosineSimilarity(a: number[], b: number[]): number;
+    function euclideanDistance(a: number[], b: number[]): number;
+    function normalize(vector: number[]): number[];
+}
+
+interface IConfigProvider {
+    getInfo(): Promise<{
+        provider?: Record<string, Record<string, unknown>>;
+        disabled_providers?: string[];
+        enabled_providers?: string[];
+        model?: string;
+        small_model?: string;
+        embedding_model?: string;
+        graph_model?: string;
+        rerank_model?: string;
+    }>;
+    getProviderConfig(providerId: string): Promise<Record<string, unknown> | undefined>;
+    getEnabledProviders(): Promise<string[]>;
+}
+interface IInstanceProvider {
+    getDirectory(): string;
+    getWorktree(): string;
+}
+interface IGlobalPathProvider {
+    home: string;
+    data: string;
+    cache: string;
+    config: string;
+    state: string;
+    log: string;
+    bin: string;
+}
+interface IInstallationProvider {
+    getVersion(): string;
+    getChannel(): string;
+    getUserAgent(): string;
+}
+interface AdapterRegistry {
+    config?: IConfigProvider;
+    instance?: IInstanceProvider;
+    global?: IGlobalPathProvider;
+    installation?: IInstallationProvider;
+}
+declare namespace Flag {
+    const EASBOT_CONFIG: string | undefined;
+    const EASBOT_CONFIG_DIR: string | undefined;
+    const EASBOT_CONFIG_CONTENT: string | undefined;
+    const EASBOT_DISABLE_PROJECT_CONFIG: boolean;
+    const EASBOT_MODELS_FETCH: boolean;
+    const EASBOT_MODELS_URL: string | undefined;
+    const EASBOT_MODELS_PATH: string | undefined;
+    const EASBOT_OUTPUT_TOKEN_MAX: number;
+    const EASBOT_ENABLE_EXPERIMENTAL_MODELS: boolean;
+    const EASBOT_DEFAULT_MODEL: string | undefined;
+}
+declare function setAdapterRegistry(registry: AdapterRegistry | undefined): void;
+declare function getAdapterRegistry(): AdapterRegistry | undefined;
+declare function hasAdapterRegistry(): boolean;
+declare function getIConfigProvider(): IConfigProvider;
+declare function getIInstanceProvider(): IInstanceProvider;
+declare function getIGlobalPathProvider(): IGlobalPathProvider;
+declare function getIInstallationProvider(): IInstallationProvider;
+declare function readFlagBool(key: string): boolean;
+declare function readFlagNumber(key: string, defaultValue: number): number;
+declare function readEnvString(key: string): string | undefined;
+
+declare const ProviderAuthMethod: z.ZodObject<{
+    type: z.ZodUnion<readonly [z.ZodLiteral<"oauth">, z.ZodLiteral<"api">]>;
+    label: z.ZodString;
+}, z.core.$strip>;
+type ProviderAuthMethod = z.infer<typeof ProviderAuthMethod>;
+declare const ProviderConfig: z.ZodObject<{
+    api: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    name: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    id: z.ZodOptional<z.ZodString>;
+    npm: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    whitelist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blacklist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        family: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        release_date: z.ZodOptional<z.ZodString>;
+        attachment: z.ZodOptional<z.ZodBoolean>;
+        reasoning: z.ZodOptional<z.ZodBoolean>;
+        temperature: z.ZodOptional<z.ZodBoolean>;
+        tool_call: z.ZodOptional<z.ZodBoolean>;
+        interleaved: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            field: z.ZodEnum<{
+                reasoning_content: "reasoning_content";
+                reasoning_details: "reasoning_details";
+            }>;
+        }, z.core.$strict>]>>>;
+        cost: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            input: z.ZodNumber;
+            output: z.ZodNumber;
+            cache_read: z.ZodOptional<z.ZodNumber>;
+            cache_write: z.ZodOptional<z.ZodNumber>;
+            context_over_200k: z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache_read: z.ZodOptional<z.ZodNumber>;
+                cache_write: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        limit: z.ZodOptional<z.ZodObject<{
+            context: z.ZodNumber;
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodNumber;
+        }, z.core.$strip>>;
+        modalities: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            input: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                pdf: "pdf";
+            }>>;
+            output: z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+                image: "image";
+                video: "video";
+                pdf: "pdf";
+            }>>;
+        }, z.core.$strip>>>;
+        experimental: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+            alpha: "alpha";
+            beta: "beta";
+            deprecated: "deprecated";
+        }>>>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        headers: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+        provider: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            npm: z.ZodString;
+        }, z.core.$strip>>>;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodAny>>>>;
+    }, z.core.$strip>>>;
+    options: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        baseURL: z.ZodOptional<z.ZodString>;
+        enterpriseUrl: z.ZodOptional<z.ZodString>;
+        setCacheKey: z.ZodOptional<z.ZodBoolean>;
+        timeout: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+    }, z.core.$catchall<z.ZodAny>>>;
+}, z.core.$strict>;
+type ProviderConfig = z.infer<typeof ProviderConfig>;
+declare const LLMConfig: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        api: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        name: z.ZodOptional<z.ZodString>;
+        env: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        id: z.ZodOptional<z.ZodString>;
+        npm: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        whitelist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        blacklist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            family: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            release_date: z.ZodOptional<z.ZodString>;
+            attachment: z.ZodOptional<z.ZodBoolean>;
+            reasoning: z.ZodOptional<z.ZodBoolean>;
+            temperature: z.ZodOptional<z.ZodBoolean>;
+            tool_call: z.ZodOptional<z.ZodBoolean>;
+            interleaved: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                field: z.ZodEnum<{
+                    reasoning_content: "reasoning_content";
+                    reasoning_details: "reasoning_details";
+                }>;
+            }, z.core.$strict>]>>>;
+            cost: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+                cache_read: z.ZodOptional<z.ZodNumber>;
+                cache_write: z.ZodOptional<z.ZodNumber>;
+                context_over_200k: z.ZodOptional<z.ZodObject<{
+                    input: z.ZodNumber;
+                    output: z.ZodNumber;
+                    cache_read: z.ZodOptional<z.ZodNumber>;
+                    cache_write: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            limit: z.ZodOptional<z.ZodObject<{
+                context: z.ZodNumber;
+                input: z.ZodOptional<z.ZodNumber>;
+                output: z.ZodNumber;
+            }, z.core.$strip>>;
+            modalities: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                input: z.ZodArray<z.ZodEnum<{
+                    text: "text";
+                    audio: "audio";
+                    image: "image";
+                    video: "video";
+                    pdf: "pdf";
+                }>>;
+                output: z.ZodArray<z.ZodEnum<{
+                    text: "text";
+                    audio: "audio";
+                    image: "image";
+                    video: "video";
+                    pdf: "pdf";
+                }>>;
+            }, z.core.$strip>>>;
+            experimental: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            status: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
+                alpha: "alpha";
+                beta: "beta";
+                deprecated: "deprecated";
+            }>>>;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            headers: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            provider: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+                npm: z.ZodString;
+            }, z.core.$strip>>>;
+            variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                disabled: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$catchall<z.ZodAny>>>>;
+        }, z.core.$strip>>>;
+        options: z.ZodOptional<z.ZodObject<{
+            apiKey: z.ZodOptional<z.ZodString>;
+            baseURL: z.ZodOptional<z.ZodString>;
+            enterpriseUrl: z.ZodOptional<z.ZodString>;
+            setCacheKey: z.ZodOptional<z.ZodBoolean>;
+            timeout: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>]>>;
+        }, z.core.$catchall<z.ZodAny>>>;
+    }, z.core.$strict>>>;
+    disabled_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled_providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model: z.ZodOptional<z.ZodString>;
+    small_model: z.ZodOptional<z.ZodString>;
+    embedding_model: z.ZodOptional<z.ZodString>;
+    graph_model: z.ZodOptional<z.ZodString>;
+    rerank_model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type LLMConfig = z.infer<typeof LLMConfig>;
+
+declare namespace Config {
+    function get(): Promise<LLMConfig>;
+    function provider(providerId: string): Promise<ProviderConfig | undefined>;
+    function enabledProviders(): Promise<string[]>;
+    function isLoaded(): boolean;
+    function clearCache(): void;
+}
+
+interface ProbeEmbeddingOptions {
+    signal?: AbortSignal;
+    probeText?: string;
+    timeoutMs?: number;
+}
+declare class ProbeEmbeddingError extends Error {
+    readonly modelId: string;
+    readonly cause: unknown;
+    constructor(modelId: string, cause: unknown);
+}
+declare function probeEmbeddingDims(model: EmbeddingModel, options?: ProbeEmbeddingOptions): Promise<number | undefined>;
+
+interface SyncMetaCompatibleDB {
+    prepare: (sql: string) => {
+        run: (...params: unknown[]) => unknown;
+    };
+    transaction: <T extends (...args: never[]) => unknown>(fn: T) => T & (() => unknown);
+}
+type MetaEntry = readonly [key: string, value: string];
+declare function syncMeta(db: SyncMetaCompatibleDB, entries: ReadonlyArray<MetaEntry>): void;
+
+interface ILLMModels {
+    embeddingLlm?: EmbeddingModel;
+    graphLlm?: LanguageModel;
+    rerankLlm?: RerankingModel;
+}
+interface ILLMInitConfig {
+    models: ILLMModels;
+}
+interface ILLMCapabilities {
+    embedding?: boolean;
+    graphLlm?: boolean;
+    rerankLlm?: boolean;
+}
+interface ILLM {
+    init(config: ILLMInitConfig): void;
+    isInitialized(): boolean;
+    capabilities?(): ILLMCapabilities;
+    reset?(): void;
+    getEmbeddingLlm?(): EmbeddingModel | undefined;
+    getGraphLlm?(): LanguageModel | undefined;
+    getRerankLlm?(): RerankingModel | undefined;
+}
+
+interface BootstrapModels {
+    embeddingLlm?: EmbeddingModel;
+    graphLlm?: LanguageModel;
+    rerankLlm?: RerankingModel;
+}
+interface BootstrapLlmOptions {
+    target: ILLM;
+    cwd: string;
+    subConfigPath?: string;
+    embedding?: boolean;
+    graph?: boolean;
+    rerank?: boolean;
+}
+interface BootstrapLlmResult {
+    loaded: {
+        embedding: boolean;
+        graph: boolean;
+        rerank: boolean;
+    };
+    hasFallback: boolean;
+    sources: {
+        embedding?: 'sub' | 'top';
+        graph?: 'sub' | 'top';
+        rerank?: 'sub' | 'top';
+    };
+}
+declare function bootstrapLlm(options: BootstrapLlmOptions): Promise<BootstrapLlmResult>;
+declare function bootstrapLlmStandalone(options: {
+    global: IGlobalPathProvider;
+    instance: {
+        directory: string;
+        worktree: string;
+    };
+}): void;
+
+export { type AdapterRegistry, type BootstrapLlmOptions, type BootstrapLlmResult, type BootstrapModels, type BuildPromptOptions, CUSTOM_PROVIDER_DEFINITIONS, Config, DEFAULT_ENABLED_PROVIDERS, EmbeddingProvider, type ExtractedEntity, type ExtractedRelation, type ExtractionResult, Flag, type GraphEntityTypeDef, GraphProvider, type GraphRelationTypeDef, type IConfigProvider, type IGlobalPathProvider, type IInstallationProvider, type IInstanceProvider, type ILLM, type ILLMCapabilities, type ILLMInitConfig, type ILLMModels, LLMConfig, LLMConfig as LLMConfigType, type MetaEntry, ModelsDev, type OpenaiCompatibleProvider, type OpenaiCompatibleProviderSettings, PROVIDER_DISPLAY_NAMES, ProbeEmbeddingError, type ProbeEmbeddingOptions, Provider, ProviderAuth, ProviderAuthMethod, ProviderAuthMethod as ProviderAuthMethodType, ProviderConfig, ProviderConfig as ProviderConfigType, ProviderError, ProviderTransform, RerankProvider, SummaryProvider, bootstrapLlm, bootstrapLlmStandalone, buildEntityExtractionPrompt, createOpenaiCompatible, extractEntitiesByRules, getAdapterRegistry, getIConfigProvider, getIGlobalPathProvider, getIInstallationProvider, getIInstanceProvider, hasAdapterRegistry, inferEntityType, initModelsRefresh, normalizeExtractionResult, openaiCompatible, parseEntityExtractionResult, probeEmbeddingDims, readEnvString, readFlagBool, readFlagNumber, sanitizeEntityToken, setAdapterRegistry, syncMeta };