@cline/core 0.0.38-nightly.1778113663

package/dist/services/llms/handler-factory.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig, AgentModel, BasicLogger, ModelInfo } from "@cline/shared";
+export declare function resolveKnownModelsFromConfig(config: AgentConfig): Record<string, ModelInfo> | undefined;
+export declare function createAgentModelFromConfig(config: AgentConfig, logger: BasicLogger | undefined): AgentModel;

package/dist/services/llms/provider-defaults.d.ts

@@ -0,0 +1,28 @@
+/** biome-ignore-all lint/style/noNonNullAssertion: static */
+import * as Llms from "@cline/llms";
+import type { ModelCatalogConfig, ModelInfo, ProviderCapability, ProviderConfig } from "./provider-settings";
+export interface BuiltInProviderManifest {
+    id: string;
+    baseUrl: string;
+    modelsSourceUrl?: string;
+    modelId: string;
+    knownModels?: Record<string, ModelInfo>;
+    capabilities?: Llms.CatalogProviderCapability[];
+    env?: readonly string[];
+    client: Llms.ProviderClient;
+    protocol?: Llms.ProviderProtocol;
+}
+export interface ProviderDefaults {
+    baseUrl: string;
+    modelId: string;
+    knownModels?: Record<string, ModelInfo>;
+    capabilities?: ProviderCapability[];
+}
+export declare const DEFAULT_MODELS_CATALOG_URL = "https://models.dev/api.json";
+export declare function clearPublicModelsCatalogCache(): void;
+export declare function getLiveModelsCatalog(options?: Pick<ModelCatalogConfig, "url" | "cacheTtlMs">): Promise<Record<string, Record<string, ModelInfo>>>;
+export declare function clearLiveModelsCatalogCache(url?: string): void;
+export declare function clearPrivateModelsCatalogCache(): void;
+export declare const OPENAI_COMPATIBLE_PROVIDERS: Record<string, ProviderDefaults>;
+export declare function getProviderConfig(providerId: string): ProviderDefaults | undefined;
+export declare function resolveProviderConfig(providerId: string, modelCatalog?: ModelCatalogConfig, config?: ProviderConfig): Promise<ProviderDefaults | undefined>;

package/dist/services/llms/provider-settings.d.ts

@@ -0,0 +1,247 @@
+import * as Llms from "@cline/llms";
+import { z } from "zod";
+import { type ProviderDefaults } from "./provider-defaults";
+export type ModelInfo = Llms.ModelInfo;
+export type ProviderClient = Llms.ProviderClient;
+export type ProviderProtocol = Llms.ProviderProtocol;
+export type ProviderId = Llms.ProviderId;
+export type ProviderCapability = Llms.ProviderCapability;
+export type ProviderConfig = Llms.ProviderConfig;
+export type BuiltInProviderId = Llms.BuiltInProviderId;
+export declare const BUILT_IN_PROVIDER: typeof Llms.BUILT_IN_PROVIDER;
+export declare const BUILT_IN_PROVIDER_IDS: [Llms.BUILT_IN_PROVIDER, ...Llms.BUILT_IN_PROVIDER[]];
+export declare const isBuiltInProviderId: typeof Llms.isBuiltInProviderId;
+export declare const normalizeProviderId: typeof Llms.normalizeProviderId;
+export type ProviderDefaultsConfig = ProviderDefaults;
+export declare const ProviderIdSchema: z.ZodString;
+export declare const ProviderProtocolSchema: z.ZodEnum<{
+    "openai-responses": "openai-responses";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-chat": "openai-chat";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+}>;
+export declare const ProviderClientSchema: z.ZodEnum<{
+    custom: "custom";
+    anthropic: "anthropic";
+    gemini: "gemini";
+    "openai-r1": "openai-r1";
+    "ai-sdk": "ai-sdk";
+    "ai-sdk-community": "ai-sdk-community";
+    openai: "openai";
+    "openai-compatible": "openai-compatible";
+    bedrock: "bedrock";
+    fetch: "fetch";
+    vertex: "vertex";
+}>;
+export declare const AuthSettingsSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    accountId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthSettings = z.infer<typeof AuthSettingsSchema>;
+export declare const ReasoningSettingsSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        medium: "medium";
+        xhigh: "xhigh";
+        none: "none";
+    }>>;
+    budgetTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReasoningSettings = z.infer<typeof ReasoningSettingsSchema>;
+export declare const AwsSettingsSchema: z.ZodObject<{
+    accessKey: z.ZodOptional<z.ZodString>;
+    secretKey: z.ZodOptional<z.ZodString>;
+    sessionToken: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    authentication: z.ZodOptional<z.ZodEnum<{
+        iam: "iam";
+        "api-key": "api-key";
+        profile: "profile";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+    useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    customModelBaseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AwsSettings = z.infer<typeof AwsSettingsSchema>;
+export declare const GcpSettingsSchema: z.ZodObject<{
+    projectId: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GcpSettings = z.infer<typeof GcpSettingsSchema>;
+export declare const AzureSettingsSchema: z.ZodObject<{
+    apiVersion: z.ZodOptional<z.ZodString>;
+    useIdentity: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AzureSettings = z.infer<typeof AzureSettingsSchema>;
+export declare const SapSettingsSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    clientSecret: z.ZodOptional<z.ZodString>;
+    tokenUrl: z.ZodOptional<z.ZodString>;
+    resourceGroup: z.ZodOptional<z.ZodString>;
+    deploymentId: z.ZodOptional<z.ZodString>;
+    useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+    api: z.ZodOptional<z.ZodEnum<{
+        orchestration: "orchestration";
+        "foundation-models": "foundation-models";
+    }>>;
+    defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type SapSettings = z.infer<typeof SapSettingsSchema>;
+export declare const OcaSettingsSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        external: "external";
+        internal: "internal";
+    }>>;
+    usePromptCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OcaSettings = z.infer<typeof OcaSettingsSchema>;
+export declare const ModelCatalogSettingsSchema: z.ZodObject<{
+    loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+    loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+    cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+    failOnError: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ModelCatalogSettings = z.infer<typeof ModelCatalogSettingsSchema>;
+export type ModelCatalogConfig = ModelCatalogSettings;
+export declare const ProviderSettingsSchema: z.ZodObject<{
+    provider: z.ZodString;
+    apiKey: z.ZodOptional<z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        accessToken: z.ZodOptional<z.ZodString>;
+        refreshToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        accountId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    model: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodEnum<{
+        "openai-responses": "openai-responses";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-chat": "openai-chat";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+    }>>;
+    client: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "ai-sdk-community": "ai-sdk-community";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        bedrock: "bedrock";
+        fetch: "fetch";
+        vertex: "vertex";
+    }>>;
+    routingProviderId: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            medium: "medium";
+            xhigh: "xhigh";
+            none: "none";
+        }>>;
+        budgetTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    aws: z.ZodOptional<z.ZodObject<{
+        accessKey: z.ZodOptional<z.ZodString>;
+        secretKey: z.ZodOptional<z.ZodString>;
+        sessionToken: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        profile: z.ZodOptional<z.ZodString>;
+        authentication: z.ZodOptional<z.ZodEnum<{
+            iam: "iam";
+            "api-key": "api-key";
+            profile: "profile";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+        useCrossRegionInference: z.ZodOptional<z.ZodBoolean>;
+        useGlobalInference: z.ZodOptional<z.ZodBoolean>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        customModelBaseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    gcp: z.ZodOptional<z.ZodObject<{
+        projectId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    azure: z.ZodOptional<z.ZodObject<{
+        apiVersion: z.ZodOptional<z.ZodString>;
+        useIdentity: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    sap: z.ZodOptional<z.ZodObject<{
+        clientId: z.ZodOptional<z.ZodString>;
+        clientSecret: z.ZodOptional<z.ZodString>;
+        tokenUrl: z.ZodOptional<z.ZodString>;
+        resourceGroup: z.ZodOptional<z.ZodString>;
+        deploymentId: z.ZodOptional<z.ZodString>;
+        useOrchestrationMode: z.ZodOptional<z.ZodBoolean>;
+        api: z.ZodOptional<z.ZodEnum<{
+            orchestration: "orchestration";
+            "foundation-models": "foundation-models";
+        }>>;
+        defaultSettings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    oca: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            external: "external";
+            internal: "internal";
+        }>>;
+        usePromptCache: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    region: z.ZodOptional<z.ZodString>;
+    apiLine: z.ZodOptional<z.ZodEnum<{
+        china: "china";
+        international: "international";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "computer-use": "computer-use";
+        oauth: "oauth";
+        vision: "vision";
+    }>>>;
+    modelCatalog: z.ZodOptional<z.ZodObject<{
+        loadLatestOnInit: z.ZodOptional<z.ZodBoolean>;
+        loadPrivateOnAuth: z.ZodOptional<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+        cacheTtlMs: z.ZodOptional<z.ZodNumber>;
+        failOnError: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProviderSettings = z.infer<typeof ProviderSettingsSchema>;
+export interface ToProviderConfigOptions {
+    includeKnownModels?: boolean;
+}
+export declare function parseSettings(input: unknown): ProviderSettings;
+export declare function safeParseSettings(input: unknown): ReturnType<typeof ProviderSettingsSchema.safeParse>;
+export declare function toProviderConfig(settings: ProviderSettings, options?: ToProviderConfigOptions): ProviderConfig;
+export declare function createProviderConfig(input: unknown): ProviderConfig;
+export declare function safeCreateProviderConfig(input: unknown): {
+    success: true;
+    config: ProviderConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};

package/dist/services/llms/runtime-config.d.ts

@@ -0,0 +1,3 @@
+import type { LlmsConfig } from "./runtime-types";
+export declare function defineLlmsConfig(config: LlmsConfig): LlmsConfig;
+export declare function loadLlmsConfigFromFile(configPath: string): Promise<LlmsConfig>;

package/dist/services/llms/runtime-registry.d.ts

@@ -0,0 +1,19 @@
+import type { ApiHandler } from "@cline/llms";
+import type { BuiltInProviderSummary, CreateHandlerInput, LlmsConfig, LlmsSdk, RegisterBuiltinProviderInput, RegisteredProviderSummary, RegisterModelInput, RegisterProviderInput } from "./runtime-types";
+export declare class DefaultLlmsSdk implements LlmsSdk {
+    private readonly configuredProviders;
+    constructor(config: LlmsConfig);
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): import("@cline/llms").BUILT_IN_PROVIDER[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+    private applyConfig;
+}
+export declare function createLlmsSdk(config: LlmsConfig): LlmsSdk;

package/dist/services/llms/runtime-types.d.ts

@@ -0,0 +1,84 @@
+import type { ApiHandler, BuiltInProviderId, HandlerFactory, LazyHandlerFactory, ModelCollection, ModelInfo, CatalogProviderCapability as ModelProviderCapability, ProviderClient, ProviderConfig, ProviderInfo, ProviderProtocol } from "@cline/llms";
+import type { ProviderCapability } from "./provider-settings";
+export type ProviderConfigDefaults = Omit<ProviderConfig, "providerId" | "modelId">;
+export interface ProviderSelectionConfig {
+    id: string;
+    models: string[];
+    defaultModel?: string;
+    builtinProviderId?: BuiltInProviderId;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    capabilities?: ProviderCapability[];
+    settings?: ProviderConfigDefaults;
+}
+export interface AdditionalModelConfig {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface CustomProviderConfig {
+    collection: ModelCollection;
+    defaults?: ProviderConfigDefaults;
+    handlerFactory?: HandlerFactory;
+    asyncHandlerFactory?: LazyHandlerFactory;
+}
+export interface LlmsConfig {
+    providers: ProviderSelectionConfig[];
+    models?: AdditionalModelConfig[];
+    customProviders?: CustomProviderConfig[];
+}
+export interface CreateHandlerInput {
+    providerId: string;
+    modelId?: string;
+    overrides?: ProviderConfigDefaults;
+}
+export interface RegisteredProviderSummary {
+    id: string;
+    models: string[];
+    defaultModel: string;
+}
+export interface BuiltInProviderSummary extends Pick<ProviderInfo, "id" | "name" | "description" | "protocol" | "baseUrl" | "capabilities" | "env"> {
+    models: string[];
+    defaultModel: string;
+    modelCount: number;
+}
+export interface RegisterBuiltinProviderInput {
+    id: string;
+    builtinProviderId: BuiltInProviderId;
+    models: Record<string, ModelInfo>;
+    name?: string;
+    description?: string;
+    protocol?: ProviderProtocol;
+    baseUrl?: string;
+    client?: ProviderClient;
+    capabilities?: ModelProviderCapability[];
+    env?: string[];
+    defaultModel?: string;
+    defaults?: ProviderConfigDefaults;
+    exposeModels?: string[];
+}
+export interface RegisterProviderInput extends CustomProviderConfig {
+    exposeModels?: string[];
+    defaultModel?: string;
+}
+export interface RegisterModelInput {
+    providerId: string;
+    modelId: string;
+    info: ModelInfo;
+}
+export interface LlmsSdk {
+    createHandler(input: CreateHandlerInput): ApiHandler;
+    createHandlerAsync(input: CreateHandlerInput): Promise<ApiHandler>;
+    registerProvider(input: RegisterProviderInput): void;
+    registerBuiltinProvider(input: RegisterBuiltinProviderInput): void;
+    registerModel(input: RegisterModelInput): void;
+    getProviders(): RegisteredProviderSummary[];
+    getBuiltInProviderIds(): BuiltInProviderId[];
+    getBuiltInProviders(): Promise<BuiltInProviderSummary[]>;
+    getModels(providerId: string): string[];
+    isProviderConfigured(providerId: string): boolean;
+    isModelConfigured(providerId: string, modelId: string): boolean;
+}

package/dist/services/local-runtime-bootstrap.d.ts

@@ -0,0 +1,45 @@
+import type { AgentConfig, AgentHooks, AgentTool, ITelemetryService, ToolApprovalRequest, ToolApprovalResult, WorkspaceInfo } from "@cline/shared";
+import type { TeamEvent } from "../extensions/tools/team";
+import type { RuntimeCapabilities } from "../runtime/capabilities";
+import type { LocalRuntimeStartOptions, StartSessionInput } from "../runtime/host/runtime-host";
+import type { RuntimeBuilderInput } from "../runtime/orchestration/session-runtime";
+import type { CoreSessionConfig } from "../types/config";
+import { type ProviderConfig } from "../types/provider-settings";
+import type { ProviderSettingsManager } from "./storage/provider-settings-manager";
+export interface PrepareLocalRuntimeBootstrapOptions {
+    input: StartSessionInput;
+    localRuntime?: LocalRuntimeStartOptions;
+    sessionId: string;
+    providerSettingsManager: ProviderSettingsManager;
+    defaultTelemetry?: ITelemetryService;
+    defaultCapabilities?: RuntimeCapabilities;
+    defaultToolPolicies?: AgentConfig["toolPolicies"];
+    /**
+     * Host-level default `fetch` threaded into `ProviderConfig.fetch` so the
+     * AI gateway providers can use a custom HTTP implementation.
+     */
+    defaultFetch?: typeof fetch;
+    onPluginEvent: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    onTeamEvent: (event: TeamEvent) => void;
+    createSpawnTool: () => AgentTool;
+    readSessionMetadata: () => Promise<Record<string, unknown> | undefined>;
+    writeSessionMetadata: (metadata: Record<string, unknown>) => Promise<void> | void;
+}
+export interface LocalRuntimeBootstrap {
+    effectiveInput: StartSessionInput;
+    config: CoreSessionConfig;
+    providerConfig: ProviderConfig;
+    workspaceMetadata: string;
+    /** Structured git + path metadata generated alongside workspaceMetadata. */
+    workspaceInfo: WorkspaceInfo;
+    extensions: AgentConfig["extensions"];
+    hooks: AgentHooks | undefined;
+    toolPolicies: AgentConfig["toolPolicies"];
+    requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult> | ToolApprovalResult;
+    pluginSandboxShutdown?: () => Promise<void>;
+    runtimeBuilderInput: RuntimeBuilderInput;
+}
+export declare function prepareLocalRuntimeBootstrap(options: PrepareLocalRuntimeBootstrapOptions): Promise<LocalRuntimeBootstrap>;

package/dist/services/plugin-tools.d.ts

@@ -0,0 +1,15 @@
+export interface PluginToolSummary {
+    name: string;
+    pluginName: string;
+    path: string;
+    source: "workspace-plugin" | "global-plugin";
+    enabled: boolean;
+    description?: string;
+}
+export declare function listPluginTools(input: {
+    workspacePath: string;
+    cwd?: string;
+    disabledToolNames?: ReadonlyArray<string>;
+    providerId?: string;
+    modelId?: string;
+}): Promise<PluginToolSummary[]>;

package/dist/services/providers/local-provider-registry.d.ts

@@ -0,0 +1,218 @@
+import { type ProviderModel } from "@cline/shared";
+import { z } from "zod";
+import type { ProviderSettings, StoredProviderSettings } from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+export declare const StoredModelEntrySchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        images: "images";
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "reasoning-effort": "reasoning-effort";
+        "computer-use": "computer-use";
+        "global-endpoint": "global-endpoint";
+        structured_output: "structured_output";
+        temperature: "temperature";
+        files: "files";
+    }>>>;
+    supportsVision: z.ZodOptional<z.ZodBoolean>;
+    supportsAttachments: z.ZodOptional<z.ZodBoolean>;
+    supportsReasoning: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type StoredModelEntry = z.infer<typeof StoredModelEntrySchema>;
+export declare const StoredProviderMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    baseUrl: z.ZodString;
+    defaultModelId: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodOptional<z.ZodEnum<{
+        "openai-responses": "openai-responses";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-chat": "openai-chat";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+    }>>;
+    client: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        anthropic: "anthropic";
+        gemini: "gemini";
+        "openai-r1": "openai-r1";
+        "ai-sdk": "ai-sdk";
+        "ai-sdk-community": "ai-sdk-community";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        bedrock: "bedrock";
+        fetch: "fetch";
+        vertex: "vertex";
+    }>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        tools: "tools";
+        streaming: "streaming";
+        "prompt-cache": "prompt-cache";
+        reasoning: "reasoning";
+        "computer-use": "computer-use";
+        temperature: "temperature";
+        files: "files";
+        "provider-tools": "provider-tools";
+        oauth: "oauth";
+        vision: "vision";
+        "local-auth": "local-auth";
+    }>>>;
+    modelsSourceUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const StoredProviderEntrySchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        baseUrl: z.ZodString;
+        defaultModelId: z.ZodOptional<z.ZodString>;
+        protocol: z.ZodOptional<z.ZodEnum<{
+            "openai-responses": "openai-responses";
+            anthropic: "anthropic";
+            gemini: "gemini";
+            "openai-chat": "openai-chat";
+            "openai-r1": "openai-r1";
+            "ai-sdk": "ai-sdk";
+        }>>;
+        client: z.ZodOptional<z.ZodEnum<{
+            custom: "custom";
+            anthropic: "anthropic";
+            gemini: "gemini";
+            "openai-r1": "openai-r1";
+            "ai-sdk": "ai-sdk";
+            "ai-sdk-community": "ai-sdk-community";
+            openai: "openai";
+            "openai-compatible": "openai-compatible";
+            bedrock: "bedrock";
+            fetch: "fetch";
+            vertex: "vertex";
+        }>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            tools: "tools";
+            streaming: "streaming";
+            "prompt-cache": "prompt-cache";
+            reasoning: "reasoning";
+            "computer-use": "computer-use";
+            temperature: "temperature";
+            files: "files";
+            "provider-tools": "provider-tools";
+            oauth: "oauth";
+            vision: "vision";
+            "local-auth": "local-auth";
+        }>>>;
+        modelsSourceUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            images: "images";
+            tools: "tools";
+            streaming: "streaming";
+            "prompt-cache": "prompt-cache";
+            reasoning: "reasoning";
+            "reasoning-effort": "reasoning-effort";
+            "computer-use": "computer-use";
+            "global-endpoint": "global-endpoint";
+            structured_output: "structured_output";
+            temperature: "temperature";
+            files: "files";
+        }>>>;
+        supportsVision: z.ZodOptional<z.ZodBoolean>;
+        supportsAttachments: z.ZodOptional<z.ZodBoolean>;
+        supportsReasoning: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type StoredProviderEntry = z.infer<typeof StoredProviderEntrySchema>;
+export declare const StoredModelsFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            baseUrl: z.ZodString;
+            defaultModelId: z.ZodOptional<z.ZodString>;
+            protocol: z.ZodOptional<z.ZodEnum<{
+                "openai-responses": "openai-responses";
+                anthropic: "anthropic";
+                gemini: "gemini";
+                "openai-chat": "openai-chat";
+                "openai-r1": "openai-r1";
+                "ai-sdk": "ai-sdk";
+            }>>;
+            client: z.ZodOptional<z.ZodEnum<{
+                custom: "custom";
+                anthropic: "anthropic";
+                gemini: "gemini";
+                "openai-r1": "openai-r1";
+                "ai-sdk": "ai-sdk";
+                "ai-sdk-community": "ai-sdk-community";
+                openai: "openai";
+                "openai-compatible": "openai-compatible";
+                bedrock: "bedrock";
+                fetch: "fetch";
+                vertex: "vertex";
+            }>>;
+            capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                tools: "tools";
+                streaming: "streaming";
+                "prompt-cache": "prompt-cache";
+                reasoning: "reasoning";
+                "computer-use": "computer-use";
+                temperature: "temperature";
+                files: "files";
+                "provider-tools": "provider-tools";
+                oauth: "oauth";
+                vision: "vision";
+                "local-auth": "local-auth";
+            }>>>;
+            modelsSourceUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>;
+        models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            name: z.ZodOptional<z.ZodString>;
+            capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                images: "images";
+                tools: "tools";
+                streaming: "streaming";
+                "prompt-cache": "prompt-cache";
+                reasoning: "reasoning";
+                "reasoning-effort": "reasoning-effort";
+                "computer-use": "computer-use";
+                "global-endpoint": "global-endpoint";
+                structured_output: "structured_output";
+                temperature: "temperature";
+                files: "files";
+            }>>>;
+            supportsVision: z.ZodOptional<z.ZodBoolean>;
+            supportsAttachments: z.ZodOptional<z.ZodBoolean>;
+            supportsReasoning: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type StoredModelsFile = z.infer<typeof StoredModelsFileSchema>;
+export declare function resolveModelsRegistryPath(manager: ProviderSettingsManager): string;
+export declare function emptyModelsFile(): StoredModelsFile;
+export declare function parseModelsFile(input: unknown): StoredModelsFile;
+export declare function readModelsFileSync(filePath: string): StoredModelsFile;
+export declare function readModelsFile(filePath: string): Promise<StoredModelsFile>;
+export declare function writeModelsFileSync(filePath: string, state: StoredModelsFile): void;
+export declare function writeModelsFile(filePath: string, state: StoredModelsFile): Promise<void>;
+export declare function toProviderModel(modelId: string, info: {
+    name?: string;
+    capabilities?: string[];
+    thinkingConfig?: unknown;
+}): ProviderModel;
+export declare function registerProviderSettingsProvider(settings: ProviderSettings): void;
+export declare function registerConfiguredProvidersFromSettings(state: StoredProviderSettings): void;
+/**
+ * Custom Provider Registry
+ *
+ * This module manages the registration of custom OpenAI-compatible providers and
+ * their models based on local JSON files. It provides functions to read/write the models
+ * registry file and to register providers with the LlmsModels system.
+ */
+export declare function registerCustomProvider(providerId: string, entry: StoredProviderEntry): void;
+export declare function ensureCustomProvidersLoadedSync(manager: ProviderSettingsManager): void;
+export declare function ensureCustomProvidersLoaded(manager: ProviderSettingsManager): Promise<void>;