@sctg/cline-core 3.84.0-beta.20260524130712

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

@@ -0,0 +1,230 @@
+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>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+    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";
+        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.ZodOptional<z.ZodNumber>;
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        maxInputTokens: z.ZodOptional<z.ZodNumber>;
+        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";
+                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.ZodOptional<z.ZodNumber>;
+            contextWindow: z.ZodOptional<z.ZodNumber>;
+            maxInputTokens: z.ZodOptional<z.ZodNumber>;
+            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>;

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

@@ -0,0 +1,70 @@
+import { type AddProviderActionRequest, type ITelemetryService, type OAuthProviderId, type ProviderCapability, type ProviderListItem, type ProviderModel, type SaveProviderSettingsActionRequest } from "@cline/shared";
+import type { ProviderClient, ProviderConfig, ProviderProtocol, ProviderSettings } from "../../services/llms/provider-settings";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+export { ensureCustomProvidersLoaded } from "./local-provider-registry";
+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 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 listLocalProviders(manager: ProviderSettingsManager): Promise<{
+    providers: ProviderListItem[];
+    settingsPath: string;
+}>;
+export declare function getLocalProviderModels(providerId: string, config?: ProviderConfig): Promise<{
+    providerId: string;
+    models: ProviderModel[];
+}>;
+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): OAuthProviderId;
+export declare function loginLocalProvider(providerId: OAuthProviderId, existing: ProviderSettings | undefined, openUrl: (url: string) => void, telemetry?: ITelemetryService): Promise<{
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+}>;
+export declare function saveLocalProviderOAuthCredentials(manager: ProviderSettingsManager, providerId: OAuthProviderId, existing: ProviderSettings | undefined, credentials: {
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+}): 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;

package/dist/services/providers/provider-config-fields.d.ts

@@ -0,0 +1,37 @@
+export type ProviderConfigFieldKey = "apiKey" | "baseUrl" | "awsRegion" | "awsProfile";
+export interface ProviderConfigFieldRequirement {
+    defaultValue?: string;
+    label?: string;
+    note?: string;
+    placeholder?: string;
+    optional?: boolean;
+}
+export interface ProviderConfigFields {
+    providerId: string;
+    authMethod: "api-key" | "oauth" | "local";
+    fields: Partial<Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>>;
+    /** Optional description shown above the fields (e.g. AWS region auto-fill hint). */
+    description?: string;
+}
+/**
+ * Project a provider into the inputs a configure-dialog should render.
+ *
+ * No fields are marked "required". `llms` no longer pre-flights credentials,
+ * so a missing API key surfaces as the provider's own auth error rather than
+ * a synthetic SDK failure. UIs may still require fields client-side if they
+ * want, but the runtime does not.
+ *
+ * - OAuth providers (`cline`, `oca`, `openai-codex`) return `authMethod:
+ *   "oauth"` with no fields; the configure UI should route to the OAuth
+ *   login flow instead.
+ * - Local auth providers return `authMethod: "local"` with no fields. The
+ *   configure UI should show provider-specific local readiness instead.
+ * - All other providers return `apiKey`. Built-in local/proxy-style providers
+ *   with user-supplied endpoints, plus user-added providers with saved
+ *   endpoints, also return a pre-filled `baseUrl` field.
+ *
+ * Returns the same fallback shape for unknown providers (single `apiKey`
+ * input, no default base URL) so callers can render a reasonable configure
+ * dialog without per-id branches.
+ */
+export declare function getProviderConfigFields(providerId: string): ProviderConfigFields;

package/dist/services/session-artifacts.d.ts

@@ -0,0 +1,17 @@
+export declare function nowIso(): string;
+export declare function unlinkIfExists(path: string | null | undefined): void;
+export interface SessionArtifactPaths {
+    messagesPath: string;
+}
+export declare class SessionArtifacts {
+    private readonly ensureSessionsDir;
+    constructor(ensureSessionsDir: () => string);
+    sessionArtifactsDir(sessionId: string): string;
+    ensureSessionArtifactsDir(sessionId: string): string;
+    sessionMessagesPath(sessionId: string): string;
+    sessionManifestPath(sessionId: string, ensureDir?: boolean): string;
+    removeSessionDirIfEmpty(sessionId: string): void;
+    removeSessionDir(sessionId: string): void;
+    removeDir(dir: string): void;
+    subagentArtifactPaths(sessionId: string, subAgentId: string, activeTeamTaskSessionId?: string): SessionArtifactPaths;
+}

package/dist/services/session-data.d.ts

@@ -0,0 +1,51 @@
+import type * as LlmsProviders from "@cline/llms";
+import type { AgentConfig, AgentEvent, AgentResult } from "@cline/shared";
+import { type SessionManifest } from "../session/models/session-manifest";
+import type { SessionRow } from "../session/models/session-row";
+import type { SessionStatus } from "../types/common";
+import type { StoredMessageWithMetadata } from "../types/session";
+import type { SessionRecord } from "../types/sessions";
+export declare function hasRuntimeHooks(hooks: AgentConfig["hooks"]): boolean;
+export declare function mergeAgentExtensions(explicitExtensions: AgentConfig["extensions"] | undefined, loadedExtensions: AgentConfig["extensions"] | undefined): AgentConfig["extensions"];
+export declare function serializeAgentEvent(event: AgentEvent): string;
+export declare function normalizeStoredMessagesForPersistence(messages: LlmsProviders.MessageWithMetadata[]): StoredMessageWithMetadata[];
+export declare function withLatestAssistantTurnMetadata(messages: LlmsProviders.Message[], result: AgentResult, previousMessages?: LlmsProviders.MessageWithMetadata[]): StoredMessageWithMetadata[];
+export declare function toSessionRecord(row: SessionRow): SessionRecord;
+export declare function normalizeTitle(title?: string | null): string | undefined;
+export declare function deriveTitleFromPrompt(prompt?: string | null): string | undefined;
+export declare function sanitizeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function resolveMetadataWithTitle(input: {
+    metadata?: Record<string, unknown> | null;
+    title?: string | null;
+    prompt?: string | null;
+}): Record<string, unknown> | undefined;
+export type MessagesFileContext = {
+    agent: "lead" | "subagent" | "teammate";
+    sessionId: string;
+    taskType?: string;
+};
+export declare function resolveMessagesFileContext(sessionId: string): MessagesFileContext;
+export declare function buildMessagesFilePayload(input: {
+    updatedAt: string;
+    context: MessagesFileContext;
+    messages: LlmsProviders.MessageWithMetadata[];
+    systemPrompt?: string;
+}): {
+    version: 1;
+    updated_at: string;
+    agent: "lead" | "subagent" | "teammate";
+    sessionId: string;
+    taskType?: string;
+    messages: StoredMessageWithMetadata[];
+    system_prompt?: string;
+};
+export declare function writeEmptyMessagesFile(path: string, startedAt: string, context: MessagesFileContext): void;
+export declare function buildManifestFromRow(row: SessionRow, overrides?: {
+    status?: SessionStatus;
+    endedAt?: string;
+    exitCode?: number;
+    metadata?: Record<string, unknown>;
+}): SessionManifest;
+export declare function withOccRetry<TFetch, TResult>(load: () => Promise<TFetch | undefined>, update: (loaded: TFetch) => Promise<TResult>, maxRetries: number): Promise<TResult | {
+    updated: false;
+}>;

package/dist/services/session-telemetry.d.ts

@@ -0,0 +1,15 @@
+import type { ITelemetryService } from "@cline/shared";
+import type { CoreSessionConfig } from "../types/config";
+import { type TelemetryAgentIdentityProperties } from "./telemetry/core-events";
+import type { enrichPromptWithMentions } from "./workspace";
+/**
+ * Emits local-only session creation telemetry (task.created/restarted and
+ * hook discovery). The transport-agnostic `session.started` event is
+ * emitted from `ClineCore.start` so it fires for every backend (local,
+ * hub, remote) at the outer API boundary.
+ */
+export declare function emitSessionCreationTelemetry(config: CoreSessionConfig, sessionId: string, isRestart: boolean, workspacePath: string, agentIdentity?: Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureHookDiscoveryTelemetry(telemetry: ITelemetryService | undefined, options: {
+    workspacePath: string;
+}): void;
+export declare function emitMentionTelemetry(telemetry: ITelemetryService | undefined, enriched: Awaited<ReturnType<typeof enrichPromptWithMentions>>): void;

package/dist/services/storage/file-team-store.d.ts

@@ -0,0 +1,28 @@
+import type { TeamRuntimeState, TeamTeammateSpec } from "@cline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+export interface FileTeamStoreOptions {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class FileTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    constructor(options?: FileTeamStoreOptions);
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    private ensureTeamDir;
+    private ensureTeamSubdir;
+    private statePath;
+    private historyPath;
+    private readEnvelope;
+}

package/dist/services/storage/provider-settings-legacy-migration.d.ts

@@ -0,0 +1,38 @@
+import { type ProviderSettings } from "../../types/provider-settings";
+import type { ProviderSettingsManager } from "./provider-settings-manager";
+export interface MigrateLegacyProviderSettingsOptions {
+    providerSettingsManager: ProviderSettingsManager;
+    dataDir?: string;
+    globalStatePath?: string;
+    secretsPath?: string;
+}
+export interface MigrateLegacyProviderSettingsResult {
+    migrated: boolean;
+    providerCount: number;
+    lastUsedProvider?: string;
+}
+export type LegacyClineUserInfo = {
+    idToken: string;
+    expiresAt: number;
+    refreshToken: string;
+    userInfo: {
+        id: string;
+        email: string;
+        displayName: string;
+        termsAcceptedAt: string;
+        clineBenchConsent: boolean;
+        createdAt: string;
+        updatedAt: string;
+    };
+    provider: string;
+    startedAt: number;
+};
+/**
+ * Resolves legacy Cline account auth data from the raw `cline:clineAccountId`
+ * secret string into the auth fields used by `ProviderSettings`.
+ *
+ * Returns `undefined` when the input is missing, empty, whitespace-only, or
+ * unparseable JSON.
+ */
+export declare function resolveLegacyClineAuth(rawAccountData: string | undefined): ProviderSettings["auth"] | undefined;
+export declare function migrateLegacyProviderSettings(options: MigrateLegacyProviderSettingsOptions): MigrateLegacyProviderSettingsResult;

package/dist/services/storage/provider-settings-manager.d.ts

@@ -0,0 +1,23 @@
+import { type ProviderConfig, type ProviderSettings, type ProviderTokenSource, type StoredProviderSettings, type ToProviderConfigOptions } from "../../types/provider-settings";
+export interface ProviderSettingsManagerOptions {
+    filePath?: string;
+    dataDir?: string;
+}
+export interface SaveProviderSettingsOptions {
+    setLastUsed?: boolean;
+    tokenSource?: ProviderTokenSource;
+}
+export declare class ProviderSettingsManager {
+    private readonly filePath;
+    private readonly dataDir?;
+    constructor(options?: ProviderSettingsManagerOptions);
+    getFilePath(): string;
+    read(): StoredProviderSettings;
+    write(state: StoredProviderSettings): void;
+    saveProviderSettings(settings: unknown, options?: SaveProviderSettingsOptions): StoredProviderSettings;
+    getProviderSettings(providerId: string): ProviderSettings | undefined;
+    getLastUsedProviderSettings(): ProviderSettings | undefined;
+    getProviderConfig(providerId: string, options?: ToProviderConfigOptions): ProviderConfig | undefined;
+    getLastUsedProviderConfig(options?: ToProviderConfigOptions): ProviderConfig | undefined;
+    refreshCatalog(): Promise<void>;
+}

package/dist/services/storage/sqlite-session-store.d.ts

@@ -0,0 +1,30 @@
+import { type SqliteDb } from "@cline/shared/db";
+import { type SessionStatus } from "../../types/common";
+import type { SessionRecord } from "../../types/sessions";
+import type { SessionStore } from "../../types/storage";
+export interface SqliteSessionStoreOptions {
+    sessionsDir?: string;
+}
+export declare class SqliteSessionStore implements SessionStore {
+    private readonly sessionsDirPath;
+    private db;
+    constructor(options?: SqliteSessionStoreOptions);
+    init(): void;
+    ensureSessionsDir(): string;
+    sessionDbPath(): string;
+    getRawDb(): SqliteDb;
+    close(): void;
+    run(sql: string, params?: unknown[]): {
+        changes?: number;
+    };
+    queryOne<T>(sql: string, params?: unknown[]): T | undefined;
+    queryAll<T>(sql: string, params?: unknown[]): T[];
+    create(record: SessionRecord): void;
+    update(record: Partial<SessionRecord> & {
+        sessionId: string;
+    }): void;
+    updateStatus(sessionId: string, status: SessionStatus, exitCode?: number | null): void;
+    get(sessionId: string): SessionRecord | undefined;
+    list(limit?: number): SessionRecord[];
+    delete(sessionId: string, cascade?: boolean): boolean;
+}

package/dist/services/storage/sqlite-team-store.d.ts

@@ -0,0 +1,34 @@
+import { type TeamRuntimeState, type TeamTeammateSpec } from "@cline/shared";
+import type { TeamEvent } from "../../extensions/tools/team";
+import type { TeamStore } from "../../types/storage";
+export interface SqliteTeamStoreOptions {
+    teamDir?: string;
+}
+export interface TeamRuntimeLoadResult {
+    state?: TeamRuntimeState;
+    teammates: TeamTeammateSpec[];
+    interruptedRunIds: string[];
+}
+export declare class SqliteTeamStore implements TeamStore {
+    private readonly teamDirPath;
+    private db;
+    constructor(options?: SqliteTeamStoreOptions);
+    init(): void;
+    private ensureTeamDir;
+    private dbPath;
+    private getRawDb;
+    private ensureSchema;
+    private run;
+    private queryOne;
+    private queryAll;
+    /** Runs `work` in a single SQLite transaction (rollback on any error). */
+    private withTransaction;
+    listTeamNames(): string[];
+    readState(teamName: string): TeamRuntimeState | undefined;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): TeamRuntimeLoadResult;
+    appendTeamEvent(teamName: string, eventType: string, payload: unknown, correlationId?: string): void;
+    persistRuntime(teamName: string, state: TeamRuntimeState, teammates: TeamTeammateSpec[]): void;
+    markInProgressRunsInterrupted(teamName: string, reason: string): string[];
+    handleTeamEvent(teamName: string, event: TeamEvent): void;
+}

package/dist/services/storage/team-store.d.ts

@@ -0,0 +1,15 @@
+export type { TeamStore } from "../../types/storage";
+export { FileTeamStore, type FileTeamStoreOptions, } from "./file-team-store";
+export { SqliteTeamStore, type SqliteTeamStoreOptions, } from "./sqlite-team-store";
+import { FileTeamStore } from "./file-team-store";
+import { type SqliteTeamStoreOptions } from "./sqlite-team-store";
+export declare function createLocalTeamStore(options?: SqliteTeamStoreOptions): {
+    init(): void;
+    listTeamNames(): string[];
+    readState(teamName: string): ReturnType<FileTeamStore["readState"]>;
+    readHistory(teamName: string, limit?: number): unknown[];
+    loadRuntime(teamName: string): ReturnType<FileTeamStore["loadRuntime"]>;
+    handleTeamEvent: FileTeamStore["handleTeamEvent"];
+    persistRuntime: FileTeamStore["persistRuntime"];
+    markInProgressRunsInterrupted: FileTeamStore["markInProgressRunsInterrupted"];
+};

package/dist/services/telemetry/ITelemetryAdapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Telemetry adapter interface for the @cline/core SDK.
+ *
+ * This is the SDK-side counterpart to the extension's ITelemetryProvider.
+ * It is intentionally free of VS Code / host-provider dependencies so that
+ * any consumer (CLI, tests, third-party integrations) can plug in their own
+ * backend without pulling in the full extension runtime.
+ */
+import type { TelemetryProperties } from "@cline/shared";
+export type { TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "@cline/shared";
+/**
+ * Telemetry adapter that an SDK consumer implements (or uses via the
+ * provided {@link OpenTelemetryAdapter}) to receive Cline telemetry events.
+ *
+ * The interface intentionally mirrors ITelemetryProvider from the extension
+ * so that shared logic can be re-used or compared easily.
+ */
+export interface ITelemetryAdapter {
+    /** Human-readable adapter name used for logging / diagnostics. */
+    readonly name: string;
+    /**
+     * Emit a standard telemetry event.
+     * Implementations may silently drop events when telemetry is disabled.
+     */
+    emit(event: string, properties?: TelemetryProperties): void;
+    /**
+     * Emit a *required* telemetry event that must not be suppressed by
+     * user opt-out settings (e.g. final opt-out confirmation events).
+     */
+    emitRequired(event: string, properties?: TelemetryProperties): void;
+    /**
+     * Record a monotonically-increasing counter metric.
+     * Implementations that do not support metrics may treat this as a no-op.
+     */
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    /**
+     * Record a histogram (distribution) metric.
+     * Implementations that do not support metrics may treat this as a no-op.
+     */
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    /**
+     * Record a gauge (point-in-time) metric.
+     * Pass `null` as `value` to retire the series identified by
+     * `name + attributes` and prevent stale gauge entries.
+     * Implementations that do not support metrics may treat this as a no-op.
+     */
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    /** Returns whether the adapter is currently accepting events. */
+    isEnabled(): boolean;
+    /** Flush any buffered events/metrics to the backend. */
+    flush(): Promise<void>;
+    /** Release all resources held by the adapter. */
+    dispose(): Promise<void>;
+}