@cerebriline/core 4.100.240

package/dist/services/marketplace.d.ts

@@ -0,0 +1,41 @@
+export type MarketplacePrimitiveType = "mcp" | "skill" | "plugin";
+export type MarketplaceEntryInput = {
+    id: string;
+    type: MarketplacePrimitiveType;
+    name?: string;
+    install?: {
+        args?: string[];
+    };
+};
+export type MarketplaceActionResult = {
+    id: string;
+    type: MarketplacePrimitiveType;
+    status: "installed" | "uninstalled";
+    message: string;
+    output?: string;
+};
+export type MarketplaceSpawnResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export type MarketplaceSpawnCommand = (command: string, args: string[]) => Promise<MarketplaceSpawnResult>;
+export type UninstallMarketplaceEntryOptions = {
+    deleteMcpServer?: (name: string) => void | Promise<void>;
+    mcpSettingsPath?: string;
+    spawnCommand?: MarketplaceSpawnCommand;
+    workspaceRoot?: string;
+};
+export declare function marketplaceEntryKey(entry: Pick<MarketplaceEntryInput, "id" | "type">): string;
+export declare function resolveMarketplaceMcpServerName(entry: MarketplaceEntryInput): string;
+export declare function uninstallMarketplaceMcpServerFromSettings(entry: MarketplaceEntryInput, options?: Pick<UninstallMarketplaceEntryOptions, "mcpSettingsPath">): {
+    name: string;
+    deleted: boolean;
+};
+export declare function getMarketplaceSkillCandidates(entry: MarketplaceEntryInput): string[];
+export declare function getGlobalMarketplaceSkillPaths(skillName: string): string[];
+export declare function findInstalledGlobalMarketplaceSkillName(entry: MarketplaceEntryInput): string | undefined;
+export declare function isMarketplaceSkillInstalled(entry: MarketplaceEntryInput): boolean;
+export declare function uninstallMarketplaceSkill(entry: MarketplaceEntryInput, options?: Pick<UninstallMarketplaceEntryOptions, "spawnCommand">): Promise<MarketplaceActionResult>;
+export declare function uninstallMarketplacePlugin(entry: MarketplaceEntryInput, options?: Pick<UninstallMarketplaceEntryOptions, "workspaceRoot">): Promise<MarketplaceActionResult>;
+export declare function uninstallMarketplaceEntry(entry: MarketplaceEntryInput, options?: UninstallMarketplaceEntryOptions): Promise<MarketplaceActionResult>;

package/dist/services/mcp-install.d.ts

@@ -0,0 +1,35 @@
+import type { McpServerTransportConfig } from "../extensions/mcp";
+export interface McpInstallOptions {
+    name: string;
+    headers?: string[];
+    targetArgs?: string[];
+    transport?: string;
+    settingsPath?: string;
+}
+export interface McpInstallResult {
+    name: string;
+    status: "installed";
+    transport: McpServerTransportConfig;
+    warnings: string[];
+}
+export declare function buildMcpInstallTransport(options: {
+    headers?: string[];
+    name: string;
+    targetArgs?: string[];
+    transport?: string;
+}): {
+    name: string;
+    transport: McpServerTransportConfig;
+    warnings: string[];
+};
+export declare function parseMcpInstallArgs(args: string[]): McpInstallOptions;
+export declare function installMcpServer(options: McpInstallOptions): McpInstallResult;
+export interface McpUninstallOptions {
+    name: string;
+    settingsPath?: string;
+}
+export interface McpUninstallResult {
+    name: string;
+    status: "uninstalled";
+}
+export declare function uninstallMcpServer(options: McpUninstallOptions): McpUninstallResult;

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

@@ -0,0 +1,52 @@
+import { type PluginMcpSettingsSyncResult } from "./plugin-mcp-settings";
+export interface PluginInstallOptions {
+    source: string;
+    sourceType?: PluginInstallSourceType;
+    cwd?: string;
+    force?: boolean;
+    npmCommand?: string;
+    officialPluginsRepo?: string;
+}
+export interface PluginInstallResult {
+    source: string;
+    installPath: string;
+    entryPaths: string[];
+    mcpSyncFailures: PluginMcpSettingsSyncResult["failures"];
+    mcpOAuthCandidates: PluginMcpOAuthCandidate[];
+}
+export interface PluginMcpOAuthCandidate {
+    name: string;
+    pluginName: string;
+    pluginPath: string;
+    transportType: "sse" | "streamableHttp";
+    lastError?: string;
+}
+export type ParsedPluginSource = {
+    type: "npm";
+    spec: string;
+    name: string;
+} | {
+    type: "git";
+    repo: string;
+    ref?: string;
+    host: string;
+    path: string;
+} | {
+    type: "remote";
+    url: string;
+    filename: string;
+} | {
+    type: "local";
+    path: string;
+} | {
+    type: "official";
+    slug: string;
+};
+export type PluginInstallSourceType = "npm" | "git" | "local" | "remote";
+export declare function isOfficialPluginSlug(source: string): boolean;
+export declare function parsePluginSource(source: string, sourceType?: PluginInstallSourceType): ParsedPluginSource;
+export declare function collectPluginMcpOAuthCandidates(input: {
+    pluginPaths: readonly string[];
+    settingsPath?: string;
+}): PluginMcpOAuthCandidate[];
+export declare function installPlugin(options: PluginInstallOptions): Promise<PluginInstallResult>;

package/dist/services/plugin-mcp-settings.d.ts

@@ -0,0 +1,31 @@
+export interface PluginMcpSettingsMutation {
+    name: string;
+    pluginName: string;
+    pluginPath: string;
+    action: "created" | "updated" | "skipped" | "removed" | "disabled";
+    reason?: string;
+}
+export interface PluginMcpSettingsSyncResult {
+    mutations: PluginMcpSettingsMutation[];
+    failures: Array<{
+        pluginPath: string;
+        pluginName?: string;
+        message: string;
+    }>;
+}
+export interface SyncPluginMcpServersToSettingsOptions {
+    pluginPaths: ReadonlyArray<string>;
+    cwd?: string;
+    workspacePath?: string;
+    settingsPath?: string;
+    providerId?: string;
+    modelId?: string;
+}
+export interface RemovePluginMcpServersFromSettingsOptions {
+    pluginPaths?: ReadonlyArray<string>;
+    pluginNames?: ReadonlyArray<string>;
+    settingsPath?: string;
+}
+export declare function syncPluginMcpServersToSettings(options: SyncPluginMcpServersToSettingsOptions): Promise<PluginMcpSettingsSyncResult>;
+export declare function disablePluginMcpServersInSettings(options: RemovePluginMcpServersFromSettingsOptions): PluginMcpSettingsMutation[];
+export declare function removePluginMcpServersFromSettings(options: RemovePluginMcpServersFromSettingsOptions): PluginMcpSettingsMutation[];

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

@@ -0,0 +1,40 @@
+import type { PluginInitializationFailure, PluginInitializationWarning } from "../extensions/plugin/plugin-load-report";
+export interface PluginToolSummary {
+    name: string;
+    pluginName: string;
+    path: string;
+    source: "workspace-plugin" | "global-plugin";
+    enabled: boolean;
+    description?: string;
+}
+export interface ListPluginToolsResult {
+    tools: PluginToolSummary[];
+    plugins: PluginContributionSummary[];
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}
+export interface PluginContributionSummary {
+    pluginName: string;
+    path: string;
+    capabilities: string[];
+    tools: string[];
+    rules: string[];
+    hooks: string[];
+    commands: string[];
+    mcpServers: string[];
+    providers: string[];
+}
+export declare function listPluginToolsWithDiagnostics(input: {
+    workspacePath: string;
+    cwd?: string;
+    disabledToolNames?: ReadonlyArray<string>;
+    providerId?: string;
+    modelId?: string;
+}): Promise<ListPluginToolsResult>;
+export declare function listPluginTools(input: {
+    workspacePath: string;
+    cwd?: string;
+    disabledToolNames?: ReadonlyArray<string>;
+    providerId?: string;
+    modelId?: string;
+}): Promise<PluginToolSummary[]>;

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

@@ -0,0 +1,13 @@
+export interface PluginUninstallOptions {
+    name?: string;
+    path?: string;
+    cwd?: string;
+    workspaceRoot?: string;
+}
+export interface PluginUninstallResult {
+    name: string;
+    installPath: string;
+    removedPaths: string[];
+    entryPaths: string[];
+}
+export declare function uninstallPlugin(options: PluginUninstallOptions): Promise<PluginUninstallResult>;

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

@@ -0,0 +1,354 @@
+import { type ModelInfo, type ProviderModel } from "@cerebriline/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>;
+    maxTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    contextWindow: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    maxInputTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        video: "video";
+        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>;
+    operation: z.ZodOptional<z.ZodEnum<{
+        language: "language";
+        "image-generation": "image-generation";
+        "speech-generation": "speech-generation";
+        "video-generation": "video-generation";
+        transcription: "transcription";
+    }>>;
+    operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        streaming: "streaming";
+        batch: "batch";
+    }>>>;
+    modalities: z.ZodOptional<z.ZodObject<{
+        input: z.ZodArray<z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            pdf: "pdf";
+        }>>;
+        output: z.ZodArray<z.ZodEnum<{
+            image: "image";
+            audio: "audio";
+            video: "video";
+            text: "text";
+            pdf: "pdf";
+        }>>;
+    }, z.core.$strip>>;
+    inputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    outputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    cacheReadsPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    cacheWritesPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    temperature: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    apiFormat: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "openai-responses": "openai-responses";
+        r1: "r1";
+    }>>;
+}, 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";
+        popular: "popular";
+    }>>>;
+    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";
+            popular: "popular";
+        }>>>;
+        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>;
+        maxTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        contextWindow: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        maxInputTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            video: "video";
+            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>;
+        operation: z.ZodOptional<z.ZodEnum<{
+            language: "language";
+            "image-generation": "image-generation";
+            "speech-generation": "speech-generation";
+            "video-generation": "video-generation";
+            transcription: "transcription";
+        }>>;
+        operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            streaming: "streaming";
+            batch: "batch";
+        }>>>;
+        modalities: z.ZodOptional<z.ZodObject<{
+            input: z.ZodArray<z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+                video: "video";
+                text: "text";
+                pdf: "pdf";
+            }>>;
+            output: z.ZodArray<z.ZodEnum<{
+                image: "image";
+                audio: "audio";
+                video: "video";
+                text: "text";
+                pdf: "pdf";
+            }>>;
+        }, z.core.$strip>>;
+        inputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        outputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        cacheReadsPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        cacheWritesPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        temperature: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+        apiFormat: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            "openai-responses": "openai-responses";
+            r1: "r1";
+        }>>;
+    }, 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";
+                popular: "popular";
+            }>>>;
+            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>;
+            maxTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            contextWindow: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            maxInputTokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                video: "video";
+                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>;
+            operation: z.ZodOptional<z.ZodEnum<{
+                language: "language";
+                "image-generation": "image-generation";
+                "speech-generation": "speech-generation";
+                "video-generation": "video-generation";
+                transcription: "transcription";
+            }>>;
+            operationModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                streaming: "streaming";
+                batch: "batch";
+            }>>>;
+            modalities: z.ZodOptional<z.ZodObject<{
+                input: z.ZodArray<z.ZodEnum<{
+                    image: "image";
+                    audio: "audio";
+                    video: "video";
+                    text: "text";
+                    pdf: "pdf";
+                }>>;
+                output: z.ZodArray<z.ZodEnum<{
+                    image: "image";
+                    audio: "audio";
+                    video: "video";
+                    text: "text";
+                    pdf: "pdf";
+                }>>;
+            }, z.core.$strip>>;
+            inputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            outputPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            cacheReadsPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            cacheWritesPrice: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            temperature: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            apiFormat: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                "openai-responses": "openai-responses";
+                r1: "r1";
+            }>>;
+        }, 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: Pick<ModelInfo, "name" | "description" | "contextWindow" | "capabilities" | "thinkingConfig" | "operation" | "operationModes" | "modalities">): 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;
+/**
+ * Apply a single provider's updated models.json entry to the live @cline/llms
+ * registry. Unlike {@link ensureCustomProvidersLoadedSync}, which loads a
+ * models.json path at most once per process, this applies on every call so
+ * writes made after startup are reflected immediately: models removed from the
+ * entry are unregistered, and the remaining entry is (re-)registered.
+ */
+export declare function syncStoredProviderRegistration(providerId: string, previous: StoredProviderEntry | undefined, next: StoredProviderEntry | undefined): void;
+/**
+ * Load models.json into the @cline/llms registry at most once per path per
+ * process; subsequent calls are no-ops. It does NOT re-read the file after
+ * writes — use {@link syncStoredProviderRegistration} to reflect a write in
+ * the live registry.
+ */
+export declare function ensureCustomProvidersLoadedSync(manager: ProviderSettingsManager): void;
+export declare function ensureCustomProvidersLoaded(manager: ProviderSettingsManager): Promise<void>;

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

@@ -0,0 +1,101 @@
+import * as LlmsModels from "@cerebriline/llms";
+import type { AddProviderActionRequest, ITelemetryService, ProviderCapability, ProviderListItem, ProviderModel, SaveProviderSettingsActionRequest, VoiceInputSelection } from "@cerebriline/shared";
+import { type ProviderOAuthCredentials } from "../../auth/provider-auth-registry";
+import { type ProviderClient, type ProviderConfig, type ProviderProtocol, type ProviderSettings } from "../../services/llms/provider-settings";
+import type { ProviderTokenSource } from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+export { ensureCustomProvidersLoaded } from "./local-provider-registry";
+export interface ListLocalProvidersOptions {
+    isClinePassEnabled?: boolean;
+}
+export interface UpdateLocalProviderRequest {
+    providerId: string;
+    name?: string;
+    baseUrl?: string;
+    apiKey?: string | null;
+    headers?: Record<string, string> | null;
+    timeoutMs?: number | null;
+    models?: string[];
+    defaultModelId?: string | null;
+    modelsSourceUrl?: string | null;
+    protocol?: ProviderProtocol | null;
+    client?: ProviderClient | null;
+    capabilities?: ProviderCapability[] | null;
+}
+export interface DeleteLocalProviderRequest {
+    providerId: string;
+}
+export interface TranscribeLocalAudioRequest {
+    providerId: string;
+    modelId: string;
+    audio: Uint8Array;
+    mediaType?: string;
+    abortSignal?: AbortSignal;
+}
+export interface TranscribeConfiguredVoiceInputRequest {
+    audio: Uint8Array;
+    mediaType?: string;
+    abortSignal?: AbortSignal;
+}
+export interface CreateConfiguredStreamingTranscriptionSessionRequest {
+    expiresAfterSeconds?: number;
+    abortSignal?: AbortSignal;
+}
+export declare function isDedicatedTranscriptionModel(model: Pick<ProviderModel, "operation">): boolean;
+export declare function addLocalProvider(manager: ProviderSettingsManager, request: Omit<AddProviderActionRequest, "action">): Promise<{
+    providerId: string;
+    settingsPath: string;
+    modelsPath: string;
+    modelsCount: number;
+}>;
+export declare function updateLocalProvider(manager: ProviderSettingsManager, request: UpdateLocalProviderRequest): Promise<{
+    providerId: string;
+    settingsPath: string;
+    modelsPath: string;
+    modelsCount: number;
+}>;
+export declare function deleteLocalProvider(manager: ProviderSettingsManager, request: DeleteLocalProviderRequest): Promise<{
+    providerId: string;
+    settingsPath: string;
+    modelsPath: string;
+}>;
+export declare function markLocalProviderEnabled(manager: ProviderSettingsManager, providerId: string, options?: {
+    tokenSource?: ProviderTokenSource;
+}): {
+    providerId: string;
+    enabled: true;
+    settingsPath: string;
+};
+export declare function listLocalProviders(manager: ProviderSettingsManager, options?: ListLocalProvidersOptions): Promise<{
+    providers: ProviderListItem[];
+    settingsPath: string;
+    voiceInput?: VoiceInputSelection;
+}>;
+export declare function getLocalProviderModels(providerId: string, config?: ProviderConfig): Promise<{
+    providerId: string;
+    models: ProviderModel[];
+}>;
+export declare function transcribeLocalAudio(manager: ProviderSettingsManager, request: TranscribeLocalAudioRequest): Promise<LlmsModels.AudioTranscriptionResult>;
+export declare function saveVoiceInputSettings(manager: ProviderSettingsManager, selection: VoiceInputSelection | undefined): Promise<{
+    settingsPath: string;
+    voiceInput?: VoiceInputSelection;
+}>;
+export declare function transcribeConfiguredVoiceInput(manager: ProviderSettingsManager, request: TranscribeConfiguredVoiceInputRequest): Promise<LlmsModels.AudioTranscriptionResult>;
+export declare function createConfiguredStreamingTranscriptionSession(manager: ProviderSettingsManager, request?: CreateConfiguredStreamingTranscriptionSessionRequest): Promise<LlmsModels.StreamingAudioTranscriptionSession>;
+export declare function saveLocalProviderSettings(manager: ProviderSettingsManager, request: Omit<SaveProviderSettingsActionRequest, "action">): {
+    providerId: string;
+    enabled: boolean;
+    settingsPath: string;
+};
+export declare function refreshProviderModelsFromSource(manager: ProviderSettingsManager, providerId: string): Promise<{
+    providerId: string;
+    refreshed: boolean;
+    modelsCount?: number;
+}>;
+export declare function normalizeOAuthProvider(provider: string): string;
+export declare function loginLocalProvider(providerId: string, existing: ProviderSettings | undefined, openUrl: (url: string) => void, telemetry?: ITelemetryService): Promise<ProviderOAuthCredentials>;
+export declare function saveLocalProviderOAuthCredentials(manager: ProviderSettingsManager, providerId: string, existing: ProviderSettings | undefined, credentials: ProviderOAuthCredentials, options?: {
+    setLastUsed?: boolean;
+}): ProviderSettings;
+export declare function loginAndSaveLocalProviderOAuthCredentials(manager: ProviderSettingsManager, providerId: string, openUrl: (url: string) => void, telemetry?: ITelemetryService): Promise<ProviderSettings>;
+export declare function resolveLocalClineAuthToken(settings: ProviderSettings | undefined): string | undefined;

package/dist/services/providers/model-source.d.ts

@@ -0,0 +1,3 @@
+export declare function extractModelIdsFromPayload(payload: unknown, providerId: string): string[];
+export declare function fetchModelIdsFromSource(url: string, providerId: string): Promise<string[]>;
+export declare function resolveModelsSourceUrl(baseUrl: string | undefined, defaultBaseUrl: string | undefined, modelsSourceUrl: string | undefined): string | undefined;