@cline/core 0.0.38-nightly.1778113663

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

@@ -0,0 +1,99 @@
+import { type AddProviderActionRequest, 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): 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;
+export type ProviderConfigFieldKey = "apiKey" | "baseUrl";
+export interface ProviderConfigFieldRequirement {
+    defaultValue?: string;
+}
+export interface ProviderConfigFields {
+    providerId: string;
+    authMethod: "api-key" | "oauth";
+    fields: Partial<Record<ProviderConfigFieldKey, ProviderConfigFieldRequirement>>;
+}
+/**
+ * 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.
+ * - 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/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/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>;
+}

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

@@ -0,0 +1,43 @@
+import type { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { MeterProvider } from "@opentelemetry/sdk-metrics";
+import type { ITelemetryAdapter, TelemetryMetadata, TelemetryProperties } from "./ITelemetryAdapter";
+export interface OpenTelemetryAdapterOptions {
+    readonly metadata: TelemetryMetadata;
+    readonly meterProvider?: MeterProvider | null;
+    readonly loggerProvider?: LoggerProvider | null;
+    readonly name?: string;
+    readonly enabled?: boolean | (() => boolean);
+    readonly distinctId?: string;
+    readonly commonProperties?: TelemetryProperties;
+}
+export declare class OpenTelemetryAdapter implements ITelemetryAdapter {
+    readonly name: string;
+    private readonly metadata;
+    private readonly meter;
+    private readonly logger;
+    private readonly enabled;
+    private distinctId?;
+    private commonProperties;
+    private counters;
+    private histograms;
+    private gauges;
+    private gaugeValues;
+    private readonly meterProvider?;
+    private readonly loggerProvider?;
+    constructor(options: OpenTelemetryAdapterOptions);
+    emit(event: string, properties?: TelemetryProperties): void;
+    emitRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    isEnabled(): boolean;
+    setDistinctId(distinctId?: string): void;
+    setCommonProperties(properties: TelemetryProperties): void;
+    updateCommonProperties(properties: TelemetryProperties): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+    private emitLog;
+    private buildAttributes;
+    private snapshotGaugeSeries;
+    private flattenProperties;
+}

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

@@ -0,0 +1,83 @@
+import type { BasicLogger, ITelemetryService, OpenTelemetryClientConfig, TelemetryMetadata } from "@cline/shared";
+import { type Tracer } from "@opentelemetry/api";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions } from "./OpenTelemetryAdapter";
+type OpenTelemetryExporterKind = "console" | "otlp";
+export interface OpenTelemetryProviderOptions extends Omit<OpenTelemetryClientConfig, "enabled" | "logsExporter" | "metricsExporter" | "tracesExporter"> {
+    serviceName?: string;
+    serviceVersion?: string;
+    enabled?: boolean;
+    logsExporter?: string | OpenTelemetryExporterKind[];
+    metricsExporter?: string | OpenTelemetryExporterKind[];
+    tracesExporter?: string | OpenTelemetryExporterKind[];
+    metricExportIntervalMs?: number;
+    logMaxQueueSize?: number;
+    logBatchSize?: number;
+    logBatchTimeoutMs?: number;
+}
+export interface CreateOpenTelemetryTelemetryServiceOptions extends OpenTelemetryProviderOptions, Pick<OpenTelemetryAdapterOptions, "name" | "distinctId" | "commonProperties"> {
+    metadata: TelemetryMetadata;
+    logger?: BasicLogger;
+}
+export declare class OpenTelemetryProvider {
+    readonly meterProvider: MeterProvider | null;
+    readonly loggerProvider: LoggerProvider | null;
+    readonly tracerProvider: NodeTracerProvider | null;
+    private readonly options;
+    constructor(options?: OpenTelemetryProviderOptions);
+    /**
+     * Returns a tracer for manual spans. Requires {@link OpenTelemetryProviderOptions.tracesExporter}
+     * so that a {@link NodeTracerProvider} is registered.
+     */
+    getTracer(name?: string, version?: string): Tracer;
+    createAdapter(options: Omit<OpenTelemetryAdapterOptions, "meterProvider" | "loggerProvider">): OpenTelemetryAdapter;
+    createTelemetryService(options: Omit<CreateOpenTelemetryTelemetryServiceOptions, keyof OpenTelemetryProviderOptions>): ITelemetryService;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+    private createMeterProvider;
+    private createTracerProvider;
+    private createLoggerProvider;
+}
+export declare function createOpenTelemetryTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+export declare function createConfiguredTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider?: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+/**
+ * Telemetry service plus the lifecycle closures (`flush`, `dispose`) every
+ * host needs to drive the underlying provider during shutdown. Returned by
+ * {@link createConfiguredTelemetryHandle} so detached daemons, the VS Code
+ * extension, and the CLI can share one canonical implementation of the
+ * "best-effort flush; settle dispose" semantics instead of each
+ * re-implementing the same closures.
+ */
+export interface ConfiguredTelemetryHandle {
+    readonly telemetry: ITelemetryService;
+    /**
+     * The underlying OpenTelemetry provider, when telemetry is enabled.
+     * `undefined` when telemetry is disabled or opted out so callers can
+     * detect the inactive case without inspecting `enabled` themselves.
+     */
+    readonly provider?: OpenTelemetryProvider;
+    /**
+     * Best-effort flush of any pending telemetry batches. Errors are
+     * swallowed so callers can `await` this in shutdown paths without
+     * blocking deactivation on a misbehaving exporter.
+     */
+    flush: () => Promise<void>;
+    /** Disposes the telemetry service and its provider concurrently. */
+    dispose: () => Promise<void>;
+}
+/**
+ * Builds a {@link ConfiguredTelemetryHandle} so hosts (CLI, VS Code, hub
+ * daemon) share one canonical flush/dispose implementation. Without a
+ * shared helper each host re-derived the same closures and they tended
+ * to drift; this factory keeps the lifecycle uniform across hosts.
+ */
+export declare function createConfiguredTelemetryHandle(options: CreateOpenTelemetryTelemetryServiceOptions): ConfiguredTelemetryHandle;
+export {};

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

@@ -0,0 +1,27 @@
+import type { BasicLogger } from "@cline/shared";
+import type { ITelemetryAdapter, TelemetryProperties } from "./ITelemetryAdapter";
+/**
+ * {@link ITelemetryAdapter} implementation that forwards telemetry to a {@link BasicLogger}.
+ *
+ * This is intentionally named *Sink* (not "adapter") to distinguish it from host logging bridges
+ * such as the CLI Pino bundle: it consumes telemetry events and writes them to the injected logger.
+ */
+export interface TelemetryLoggerSinkOptions {
+    logger?: BasicLogger;
+    name?: string;
+    enabled?: boolean | (() => boolean);
+}
+export declare class TelemetryLoggerSink implements ITelemetryAdapter {
+    readonly name: string;
+    private readonly logger?;
+    private readonly enabled;
+    constructor(options?: TelemetryLoggerSinkOptions);
+    emit(event: string, properties?: TelemetryProperties): void;
+    emitRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    isEnabled(): boolean;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}

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

@@ -0,0 +1,34 @@
+import type { BasicLogger, ITelemetryService, TelemetryMetadata, TelemetryProperties } from "@cline/shared";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+export interface TelemetryServiceOptions {
+    adapters?: ITelemetryAdapter[];
+    metadata?: Partial<TelemetryMetadata>;
+    distinctId?: string;
+    commonProperties?: TelemetryProperties;
+    logger?: BasicLogger;
+}
+export declare class TelemetryService implements ITelemetryService {
+    private adapters;
+    private metadata;
+    private distinctId?;
+    private commonProperties;
+    constructor(options?: TelemetryServiceOptions);
+    addAdapter(adapter: ITelemetryAdapter): void;
+    setDistinctId(distinctId?: string): void;
+    setMetadata(metadata: Partial<TelemetryMetadata>): void;
+    updateMetadata(metadata: Partial<TelemetryMetadata>): void;
+    setCommonProperties(properties: TelemetryProperties): void;
+    updateCommonProperties(properties: TelemetryProperties): void;
+    isEnabled(): boolean;
+    capture(input: {
+        event: string;
+        properties?: TelemetryProperties;
+    }): void;
+    captureRequired(event: string, properties?: TelemetryProperties): void;
+    recordCounter(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordHistogram(name: string, value: number, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    recordGauge(name: string, value: number | null, attributes?: TelemetryProperties, description?: string, required?: boolean): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+    private buildAttributes;
+}