@cerebriline/core 4.100.240

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,99 @@
+import type { BasicLogger, ITelemetryService, OpenTelemetryClientConfig, TelemetryMetadata } from "@cerebriline/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;
+    /**
+     * Skip the automatic `telemetry.provider_created` event during construction
+     * and expose it as {@link ConfiguredTelemetryHandle.emitProviderCreated}
+     * instead. Metadata is stamped onto events at capture time, so hosts that
+     * resolve identity metadata asynchronously (e.g. over the host bridge) defer
+     * the event until that metadata is applied.
+     */
+    deferProviderCreatedEvent?: boolean;
+}
+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;
+    emitProviderCreated: () => void;
+};
+export declare function createConfiguredTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider?: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+    emitProviderCreated?: () => void;
+};
+/**
+ * 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>;
+    /**
+     * Emits the `telemetry.provider_created` event. Only present when the
+     * handle was created with `deferProviderCreatedEvent: true` and telemetry
+     * is enabled; the host must call it once its identity metadata is applied.
+     */
+    emitProviderCreated?: () => 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 "@cerebriline/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,40 @@
+import type { BasicLogger, ITelemetryService, TelemetryMetadata, TelemetryProperties } from "@cerebriline/shared";
+import type { ITelemetryAdapter } from "./ITelemetryAdapter";
+export interface TelemetryServiceOptions {
+    adapters?: ITelemetryAdapter[];
+    metadata?: Partial<TelemetryMetadata>;
+    distinctId?: string;
+    /**
+     * Deterministic per-device identifier attached to every event as
+     * `device_id`. Defaults to {@link resolveCoreDeviceId}
+     */
+    deviceId?: string;
+    commonProperties?: TelemetryProperties;
+    logger?: BasicLogger;
+}
+export declare class TelemetryService implements ITelemetryService {
+    private adapters;
+    private metadata;
+    private distinctId?;
+    private readonly deviceId;
+    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;
+}

package/dist/services/telemetry/core-events.d.ts

@@ -0,0 +1,396 @@
+import { type CaptureAgentUnexpectedReasoningTokensInput, type CaptureTaskLifecycleEventInput, captureAgentUnexpectedReasoningTokens, captureTaskLifecycleEvent, type ITelemetryService, type TelemetryProperties } from "@cerebriline/shared";
+import type { CoreCompactionBudgetPolicyIntent, CoreCompactionLiveTailHandling } from "../../types/config";
+export type TelemetryAgentKind = "root" | "subagent" | "team_lead" | "team_teammate";
+export interface TelemetryAgentIdentityProperties {
+    agentId: string;
+    agentKind: TelemetryAgentKind;
+    conversationId?: string;
+    parentAgentId?: string;
+    createdByAgentId?: string;
+    isSubagent: boolean;
+    teamId?: string;
+    teamName?: string;
+    teamRole?: "lead" | "teammate";
+    teamAgentId?: string;
+}
+export declare const CORE_TELEMETRY_EVENTS: {
+    readonly CLIENT: {
+        readonly EXTENSION_ACTIVATED: "user.extension_activated";
+    };
+    readonly SESSION: {
+        readonly STARTED: "session.started";
+        readonly ENDED: "session.ended";
+    };
+    readonly AGENT: {
+        readonly UNEXPECTED_REASONING_TOKENS: "agent.reasoning.unexpected_tokens";
+    };
+    readonly USER: {
+        readonly AUTH_STARTED: "user.auth_started";
+        readonly AUTH_SUCCEEDED: "user.auth_succeeded";
+        readonly AUTH_FAILED: "user.auth_failed";
+        readonly AUTH_LOGGED_OUT: "user.auth_logged_out";
+        readonly AUTH_REFRESH_SOFT_FAILURE: "user.auth_refresh_soft_failure";
+        readonly AUTH_RUN_RETRY: "user.auth_run_retry";
+        readonly PROVIDER_CONFIGURED: "user.provider_configured";
+        readonly TELEMETRY_OPT_OUT: "user.opt_out";
+    };
+    readonly TASK: {
+        readonly CREATED: "task.created";
+        readonly RESTARTED: "task.restarted";
+        readonly COMPLETED: "task.completed";
+        readonly CONVERSATION_TURN: "task.conversation_turn";
+        readonly TOKEN_USAGE: "task.tokens";
+        readonly MODE_SWITCH: "task.mode";
+        readonly TOOL_USED: "task.tool_used";
+        readonly SKILL_USED: "task.skill_used";
+        readonly DIFF_EDIT_FAILED: "task.diff_edit_failed";
+        readonly PROVIDER_API_ERROR: "task.provider_api_error";
+        readonly MISTAKE_LIMIT_REACHED: "task.mistake_limit_reached";
+        readonly PROVIDER_REQUEST_STARTED: "task.provider_request_started";
+        readonly PROVIDER_STREAM_STARTED: "task.provider_stream_started";
+        readonly FIRST_CHUNK_RECEIVED: "task.first_chunk_received";
+        readonly PROVIDER_STREAM_FAILED: "task.provider_stream_failed";
+        readonly CANCELLED: "task.cancelled";
+        readonly MENTION_USED: "task.mention_used";
+        readonly MENTION_FAILED: "task.mention_failed";
+        readonly MENTION_SEARCH_RESULTS: "task.mention_search_results";
+        readonly AGENT_CREATED: "task.agent_created";
+        readonly AGENT_TEAM_CREATED: "task.agent_team_created";
+        readonly SUBAGENT_STARTED: "task.subagent_started";
+        readonly SUBAGENT_COMPLETED: "task.subagent_completed";
+        readonly COMPACTION_EXECUTED: "task.compaction_executed";
+        readonly COMPACTION_SKIPPED: "task.compaction_skipped";
+        readonly COMPACTION_BUDGET_EMERGENCY: "task.compaction_budget_emergency";
+    };
+    readonly HOOKS: {
+        readonly DISCOVERY_COMPLETED: "hooks.discovery_completed";
+    };
+    readonly WORKSPACE: {
+        readonly INITIALIZED: "workspace.initialized";
+        readonly INIT_ERROR: "workspace.init_error";
+        readonly PATH_RESOLVED: "workspace.path_resolved";
+    };
+    readonly SDK: {
+        readonly ERROR: "sdk.error";
+        readonly TOOL_TIMEOUT: "sdk.tool_timeout";
+        readonly PLAN_MODE_COMMAND_BLOCKED: "sdk.plan_mode_command_blocked";
+    };
+    readonly FEATURE_FLAGS: {
+        readonly FLAG_CALLED: "$feature_flag_called";
+    };
+};
+export interface RunCommandsTimeoutTelemetryProperties {
+    tool_name: "run_commands";
+    effective_timeout_ms: number;
+    timeout_source: "default_setting" | "configured_setting";
+    command_count: number;
+    duration_ms: number;
+    ulid?: string;
+    mode?: string;
+    source?: string;
+    session_id?: string;
+    agent_id?: string;
+    conversation_id?: string;
+    run_id?: string;
+    iteration?: number;
+    tool_call_id?: string;
+}
+export { captureAgentUnexpectedReasoningTokens, captureTaskLifecycleEvent, type CaptureAgentUnexpectedReasoningTokensInput, type CaptureTaskLifecycleEventInput, };
+export interface WorkspaceInitializedProperties {
+    root_count: number;
+    vcs_types: ReadonlyArray<string>;
+    init_duration_ms?: number;
+    feature_flag_enabled?: boolean;
+    is_remote_workspace?: boolean;
+}
+export interface WorkspaceInitErrorProperties {
+    fallback_to_single_root: boolean;
+    workspace_count?: number;
+}
+export interface WorkspacePathResolvedProperties {
+    ulid: string;
+    context: string;
+    resolution_type: "hint_provided" | "fallback_to_primary" | "cross_workspace_search";
+    hint_type?: "workspace_name" | "workspace_path" | "invalid";
+    resolution_success?: boolean;
+    target_workspace_index?: number;
+    is_multi_root_enabled?: boolean;
+}
+export declare function captureExtensionActivated(telemetry: ITelemetryService | undefined): void;
+export declare function captureWorkspaceInitialized(telemetry: ITelemetryService | undefined, properties: WorkspaceInitializedProperties): void;
+export declare function captureWorkspaceInitError(telemetry: ITelemetryService | undefined, error: Error | string, properties: WorkspaceInitErrorProperties): void;
+export declare function captureWorkspacePathResolved(telemetry: ITelemetryService | undefined, properties: WorkspacePathResolvedProperties): void;
+export declare function captureAuthStarted(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureAuthSucceeded(telemetry: ITelemetryService | undefined, provider?: string, details?: {
+    sessionId?: string;
+    sessionDurationMs?: number;
+}): void;
+export declare function captureAuthFailed(telemetry: ITelemetryService | undefined, provider?: string, errorMessage?: string, details?: {
+    requestId?: string;
+}): void;
+export declare function captureAuthLoggedOut(telemetry: ITelemetryService | undefined, provider?: string, reason?: string, details?: {
+    status?: number;
+    errorCode?: string;
+    sessionId?: string;
+    sessionDurationMs?: number;
+    request_id?: string;
+}): void;
+/**
+ * Fires when a token refresh fails for a reason that does NOT invalidate the
+ * session (network error, timeout, 5xx) and stored credentials were kept.
+ * Before the transient-vs-invalid_grant fix, `tokenExpired: true` instances
+ * were misclassified as invalid grants and wiped stored credentials — this
+ * event is the "prevented logout" counter for tracking that fix in
+ * production.
+ */
+export declare function captureAuthRefreshSoftFailure(telemetry: ITelemetryService | undefined, provider?: string, details?: {
+    status?: number;
+    errorCode?: string;
+    request_id?: string;
+    errorName?: string;
+    tokenExpired?: boolean;
+    sessionId?: string;
+    sessionDurationMs?: number;
+}): void;
+/**
+ * Fires when a run failed with an auth-like error, credentials were
+ * refreshed, and the run was retried once. `recovered: true` means the retry
+ * completed — a run that would previously have surfaced a raw provider 401
+ * (e.g. a teammate stranded on a spawn-time token snapshot past its TTL).
+ */
+export declare function captureAuthRunRetry(telemetry: ITelemetryService | undefined, provider?: string, details?: {
+    recovered?: boolean;
+}): void;
+/**
+ * Fires when the user finishes configuring a "bring your own provider"
+ * (API-key based) provider during onboarding or via settings.
+ *
+ * Unlike the OAuth/device-code `captureAuth*` events, the configure step is a
+ * synchronous local credential save with no network roundtrip, so there is no
+ * start/fail counterpart — the credential is validated lazily on the first
+ * subsequent API call. Mirrors the `{ provider }` payload shape of
+ * {@link captureAuthSucceeded} for funnel consistency.
+ */
+export declare function captureProviderConfigured(telemetry: ITelemetryService | undefined, provider?: string): void;
+export declare function captureTelemetryOptOut(telemetry: ITelemetryService | undefined, properties?: TelemetryProperties): void;
+export declare function identifyAccount(telemetry: ITelemetryService | undefined, account: {
+    id?: string;
+    email?: string;
+    provider?: string;
+    organizationId?: string;
+    organizationName?: string;
+    memberId?: string;
+}): void;
+export declare function captureTaskCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureTaskRestarted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    apiProvider?: string;
+    openAiCompatibleDomain?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+/**
+ * Distinguishes the trigger that produced a `task.completed` telemetry event.
+ *
+ * - `submit_and_exit`: the assistant explicitly declared completion by
+ *   invoking the canonical completion tool. Parity with original Cline's
+ *   `attempt_completion`-anchored emission.
+ * - `shutdown`: the session lifecycle completed (typically a non-interactive
+ *   single-run that finished without an explicit completion tool). Acts as a
+ *   safety-net so we still report completed runs that never observed
+ *   `submit_and_exit`.
+ */
+export type TaskCompletedSource = "submit_and_exit" | "shutdown";
+export declare function captureTaskCompleted(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    modelId?: string;
+    mode?: string;
+    durationMs?: number;
+    source?: TaskCompletedSource;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureConversationTurnEvent(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    provider?: string;
+    model?: string;
+    source: "user" | "assistant";
+    mode?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureTokenUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    /** Uncached input tokens only — disjoint from the cache buckets. */
+    tokensIn: number;
+    tokensOut: number;
+    cacheWriteTokens?: number;
+    cacheReadTokens?: number;
+    /** This request's cost delta, not a running total. */
+    totalCost?: number;
+    provider?: string;
+    model: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureModeSwitch(telemetry: ITelemetryService | undefined, ulid: string, mode?: string): void;
+export declare function captureToolUsage(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    tool: string;
+    modelId?: string;
+    provider?: string;
+    autoApproved?: boolean;
+    success: boolean;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureSkillUsed(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    skillName: string;
+    skillSource: "global" | "project";
+    skillsAvailableGlobal: number;
+    skillsAvailableProject: number;
+    provider?: string;
+    modelId?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureDiffEditFailure(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    modelId?: string;
+    provider?: string;
+    errorType?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureProviderApiError(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    model: string;
+    errorMessage: string;
+    provider?: string;
+    errorStatus?: number;
+    requestId?: string;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+/**
+ * Records when the consecutive mistake limit is reached, right before the
+ * limit decision (host prompt / auto-stop) is resolved.
+ */
+export declare function captureMistakeLimitReached(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    model: string;
+    provider?: string;
+    /** What kind of mistake tripped the limit. */
+    reason: string;
+    consecutiveMistakes: number;
+    maxConsecutiveMistakes: number;
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureRunCommandsTimeout(telemetry: ITelemetryService | undefined, properties: RunCommandsTimeoutTelemetryProperties): void;
+export interface PlanModeCommandBlockedTelemetryProperties {
+    tool_name: "run_commands" | "sed" | "extract_document";
+    /**
+     * Short description of the blocked construct (e.g. "`rm`", "`sed -i`
+     * (in-place edit)"). Never contains raw command content.
+     */
+    blocked_construct: string;
+    command_count: number;
+    agent_id?: string;
+    conversation_id?: string;
+    run_id?: string;
+    iteration?: number;
+    tool_call_id?: string;
+}
+export declare function capturePlanModeCommandBlocked(telemetry: ITelemetryService | undefined, properties: PlanModeCommandBlockedTelemetryProperties): void;
+export declare function captureMentionUsed(telemetry: ITelemetryService | undefined, mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit", contentLength?: number): void;
+export declare function captureMentionFailed(telemetry: ITelemetryService | undefined, mentionType: "file" | "folder" | "url" | "problems" | "terminal" | "git-changes" | "commit", errorType: "not_found" | "permission_denied" | "network_error" | "parse_error" | "unknown", errorMessage?: string): void;
+export declare function captureMentionSearchResults(telemetry: ITelemetryService | undefined, query: string, resultCount: number, searchType: "file" | "folder" | "all", isEmpty: boolean): void;
+export declare function captureAgentCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    modelId?: string;
+    provider?: string;
+} & TelemetryAgentIdentityProperties): void;
+export declare function captureAgentTeamCreated(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    teamId: string;
+    teamName: string;
+    leadAgentId?: string;
+    restoredFromPersistence?: boolean;
+}): void;
+export declare function captureSubagentExecution(telemetry: ITelemetryService | undefined, properties: {
+    ulid: string;
+    durationMs: number;
+    outputLines?: number;
+    event: "created" | "started" | "ended";
+    agentId: string;
+    parentId?: string;
+    errorMessage?: string;
+    type?: "agent" | "team";
+} & Partial<TelemetryAgentIdentityProperties>): void;
+export declare function captureHookDiscovery(telemetry: ITelemetryService | undefined, hookName: string, globalCount: number, workspaceCount: number): void;
+/**
+ * Identifies which compaction implementation produced a
+ * `task.compaction_executed` / `task.compaction_skipped` event.
+ *
+ * - `basic`   — built-in token-budget truncation
+ *   (see `extensions/context/basic-compaction.ts`).
+ * - `agentic` — built-in LLM-powered summarization
+ *   (see `extensions/context/agentic-compaction.ts`).
+ * - `custom`  — user-supplied `compaction.compact()` callback on
+ *   `CoreSessionConfig`.
+ */
+export type TelemetryCompactionStrategy = "basic" | "agentic" | "custom";
+/**
+ * Trigger mode for a compaction attempt.
+ *
+ * - `auto`   — fired automatically by `createContextCompactionPrepareTurn`
+ *   when input tokens reach the fixed compaction threshold.
+ * - `manual` — user-initiated (e.g. CLI `/compact`).
+ * - `overflow_recovery` — forced by the runtime after a provider rejected
+ *   the request as exceeding the model's context window.
+ */
+export type TelemetryCompactionMode = "auto" | "manual" | "overflow_recovery";
+export interface CaptureCompactionExecutedProperties {
+    ulid: string;
+    strategy: TelemetryCompactionStrategy;
+    mode: TelemetryCompactionMode;
+    messagesBefore: number;
+    messagesAfter: number;
+    messagesRemoved: number;
+    /** Full-request token estimates, in the same units as the trigger and limit. */
+    tokensBefore: number;
+    tokensAfter: number;
+    tokensSaved: number;
+    triggerTokens: number;
+    maxInputTokens: number;
+    thresholdRatio: number;
+    durationMs: number;
+    provider?: string;
+    modelId?: string;
+}
+export declare function captureCompactionExecuted(telemetry: ITelemetryService | undefined, properties: CaptureCompactionExecutedProperties & Partial<TelemetryAgentIdentityProperties>): void;
+export interface CaptureCompactionSkippedProperties {
+    ulid: string;
+    strategy: TelemetryCompactionStrategy;
+    mode: TelemetryCompactionMode;
+    /**
+     * Why the strategy decided not to compact. Currently only one value is
+     * emitted by the wrapper:
+     * - `no_result` — strategy returned `undefined` (e.g. there was nothing
+     *   safe to remove). Strategy *exceptions* propagate up instead of
+     *   firing telemetry, so no `strategy_error` value is emitted today.
+     * The field is kept loosely typed (`string`) so additional reasons can
+     * be introduced without changing the schema.
+     */
+    reason: string;
+    /** Full-request token estimate, in the same units as the trigger and limit. */
+    tokensBefore: number;
+    triggerTokens: number;
+    maxInputTokens: number;
+    thresholdRatio: number;
+    durationMs: number;
+    provider?: string;
+    modelId?: string;
+}
+export declare function captureCompactionSkipped(telemetry: ITelemetryService | undefined, properties: CaptureCompactionSkippedProperties & Partial<TelemetryAgentIdentityProperties>): void;
+export interface CaptureCompactionBudgetEmergencyProperties {
+    ulid: string;
+    strategy: TelemetryCompactionStrategy;
+    mode: TelemetryCompactionMode;
+    policyIntent: CoreCompactionBudgetPolicyIntent;
+    actionCount: number;
+    warningCount: number;
+    liveTailHandling: CoreCompactionLiveTailHandling;
+    provider?: string;
+    modelId?: string;
+}
+export declare function captureCompactionBudgetEmergency(telemetry: ITelemetryService | undefined, properties: CaptureCompactionBudgetEmergencyProperties & Partial<TelemetryAgentIdentityProperties>): void;

package/dist/services/telemetry/distinct-id.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCoreDeviceId(): string;
+export declare function resolveCoreDistinctId(explicitDistinctId?: string): string;

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

@@ -0,0 +1,4 @@
+export { resolveCoreDeviceId, resolveCoreDistinctId } from "./distinct-id";
+export type { ITelemetryAdapter, TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "./ITelemetryAdapter";
+export { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions, } from "./OpenTelemetryAdapter";
+export { type ConfiguredTelemetryHandle, type CreateOpenTelemetryTelemetryServiceOptions, createConfiguredTelemetryHandle, createConfiguredTelemetryService, createOpenTelemetryTelemetryService, OpenTelemetryProvider, type OpenTelemetryProviderOptions, } from "./OpenTelemetryProvider";

package/dist/services/telemetry/index.js

@@ -0,0 +1 @@
+import{existsSync as N,mkdirSync as G,readFileSync as v,writeFileSync as u}from"node:fs";import{resolve as g}from"node:path";import{resolveSessionDataDir as S}from"@cerebriline/shared/storage";import{nanoid as b}from"nanoid";import*as c from"node-machine-id";var m="machine-id",C,h=!1;function R(){if(!h)C=w(),h=!0;return C??q()}function X(f){let P=f?.trim();if(P)return P;let A=w();if(A)return A;return q()}function d(){let f=c;return f.machineIdSync??f.default?.machineIdSync}function w(){try{let f=d();if(!f)return;return f().trim()||void 0}catch{return}}function q(){let f=S(),P=g(f,m);try{if(N(P)){let O=v(P,"utf8").trim();if(O.length>0)return O}}catch{}let A=`cl-${b()}`;try{G(f,{recursive:!0}),u(P,A,"utf8")}catch{}return A}class Y{name;metadata;meter;logger;enabled;distinctId;commonProperties;counters=new Map;histograms=new Map;gauges=new Map;gaugeValues=new Map;meterProvider;loggerProvider;constructor(f){this.name=f.name??"OpenTelemetryAdapter",this.metadata={...f.metadata},this.meterProvider=f.meterProvider,this.loggerProvider=f.loggerProvider,this.meter=f.meterProvider?.getMeter("cline")??null,this.logger=f.loggerProvider?.getLogger("cline")??null,this.enabled=f.enabled??!0,this.distinctId=f.distinctId,this.commonProperties=f.commonProperties?{...f.commonProperties}:{}}emit(f,P){if(!this.isEnabled())return;this.emitLog(f,P,!1)}emitRequired(f,P){this.emitLog(f,P,!0)}recordCounter(f,P,A,O,j=!1){if(!this.meter||!j&&!this.isEnabled())return;let H=this.counters.get(f);if(!H)H=this.meter.createCounter(f,O?{description:O}:void 0),this.counters.set(f,H);H.add(P,this.flattenProperties(this.buildAttributes(A)))}recordHistogram(f,P,A,O,j=!1){if(!this.meter||!j&&!this.isEnabled())return;let H=this.histograms.get(f);if(!H)H=this.meter.createHistogram(f,O?{description:O}:void 0),this.histograms.set(f,H);H.record(P,this.flattenProperties(this.buildAttributes(A)))}recordGauge(f,P,A,O,j=!1){if(!this.meter||!j&&!this.isEnabled())return;let H=this.buildAttributes(A),$=JSON.stringify(H),K=this.gaugeValues.get(f);if(P===null){if(K){if(K.delete($),K.size===0)this.gaugeValues.delete(f),this.gauges.delete(f)}return}let T=K;if(!T)T=new Map,this.gaugeValues.set(f,T);if(!this.gauges.has(f)){let J=this.meter.createObservableGauge(f,O?{description:O}:void 0);J.addCallback((B)=>{for(let M of this.snapshotGaugeSeries(f))B.observe(M.value,this.flattenProperties(M.attributes))}),this.gauges.set(f,J)}T.set($,{value:P,attributes:H})}isEnabled(){return typeof this.enabled==="function"?this.enabled():this.enabled}setDistinctId(f){this.distinctId=f}setCommonProperties(f){this.commonProperties={...f}}updateCommonProperties(f){this.commonProperties={...this.commonProperties,...f}}async flush(){await Promise.all([this.meterProvider?.forceFlush?.(),this.loggerProvider?.forceFlush?.()])}async dispose(){await Promise.all([this.meterProvider?.shutdown?.(),this.loggerProvider?.shutdown?.()])}emitLog(f,P,A){if(!this.logger)return;let O=this.flattenProperties(this.buildAttributes(P,A));this.logger.emit({severityText:"INFO",body:f,attributes:O})}buildAttributes(f,P=!1){return{...this.commonProperties,...this.metadata,...f,...this.distinctId?{distinct_id:this.distinctId}:{},...P?{_required:!0}:{}}}snapshotGaugeSeries(f){let P=this.gaugeValues.get(f);if(!P)return[];return Array.from(P.values(),(A)=>({value:A.value,attributes:A.attributes?{...A.attributes}:void 0}))}flattenProperties(f,P="",A=new WeakSet,O=0){if(!f)return{};let j={},H=100,$=10;for(let[K,T]of Object.entries(f)){if(K==="__proto__"||K==="constructor"||K==="prototype")continue;let J=P?`${P}.${K}`:K;if(T===null||T===void 0){j[J]=String(T);continue}if(Array.isArray(T)){let B=T.length>H?T.slice(0,H):T;try{j[J]=JSON.stringify(B)}catch{j[J]="[UnserializableArray]"}if(T.length>H)j[`${J}_truncated`]=!0,j[`${J}_original_length`]=T.length;continue}if(typeof T==="object"){if(T instanceof Date){j[J]=T.toISOString();continue}if(T instanceof Error){j[J]=T.message;continue}if(A.has(T)){j[J]="[Circular]";continue}if(O>=$){j[J]="[MaxDepthExceeded]";continue}A.add(T),Object.assign(j,this.flattenProperties(T,J,A,O+1));continue}if(r(T)){j[J]=T;continue}try{j[J]=JSON.stringify(T)}catch{j[J]=String(T)}}return j}}function r(f){return typeof f==="string"||typeof f==="number"||typeof f==="boolean"}import{metrics as Af,trace as Of}from"@opentelemetry/api";import{logs as jf}from"@opentelemetry/api-logs";import{OTLPLogExporter as Hf}from"@opentelemetry/exporter-logs-otlp-http";import{OTLPMetricExporter as Tf}from"@opentelemetry/exporter-metrics-otlp-http";import{OTLPTraceExporter as $f}from"@opentelemetry/exporter-trace-otlp-http";import{resourceFromAttributes as Jf}from"@opentelemetry/resources";import{BatchLogRecordProcessor as Wf,ConsoleLogRecordExporter as Kf,LoggerProvider as Xf}from"@opentelemetry/sdk-logs";import{ConsoleMetricExporter as Yf,MeterProvider as Zf,PeriodicExportingMetricReader as y}from"@opentelemetry/sdk-metrics";import{BatchSpanProcessor as Qf,ConsoleSpanExporter as Bf,SimpleSpanProcessor as Rf}from"@opentelemetry/sdk-trace-base";import{NodeTracerProvider as Ff}from"@opentelemetry/sdk-trace-node";import{ATTR_SERVICE_NAME as Vf,ATTR_SERVICE_VERSION as Uf}from"@opentelemetry/semantic-conventions";import{mkdirSync as df,readFileSync as l,statSync as n,writeFileSync as rf}from"node:fs";import{CONFIGURABLE_MODEL_TOOL_NAMES as p}from"@cerebriline/shared";import{resolveGlobalSettingsPath as a}from"@cerebriline/shared/storage";import{z as W}from"zod";import{AGENT_UNEXPECTED_REASONING_TOKENS_EVENT as zf,captureAgentUnexpectedReasoningTokens as Df,captureTaskLifecycleEvent as xf,SDK_ERROR_TELEMETRY_EVENT as Nf,TASK_CANCELLED_EVENT as Gf,TASK_FIRST_CHUNK_RECEIVED_EVENT as vf,TASK_PROVIDER_REQUEST_STARTED_EVENT as uf,TASK_PROVIDER_STREAM_FAILED_EVENT as gf,TASK_PROVIDER_STREAM_STARTED_EVENT as Sf}from"@cerebriline/shared";var F=W.preprocess((f)=>Array.isArray(f)?f.filter((P)=>typeof P==="string").map((P)=>P.trim()).filter(Boolean):void 0,W.array(W.string()).optional()).transform((f)=>{if(!f)return;let P=[...new Set(f)].sort((A,O)=>A.localeCompare(O));return P.length>0?P:void 0}),i=W.enum(["basic","agentic"]).catch("agentic"),s=W.partialRecord(W.enum(p),W.object({enabled:W.boolean()}).strip()).optional(),o=W.enum(["plan","act"]),E=W.object({telemetryOptOut:W.boolean().default(!1).catch(!1),autoUpdateEnabled:W.boolean().default(!0).catch(!0),compactionStrategy:i.optional(),compactionEnabled:W.boolean().optional().catch(void 0),planActMode:o.optional().catch(void 0),toolAutoApprove:W.boolean().optional().catch(void 0),tuiTheme:W.string().optional().catch(void 0),disabledTools:F.optional(),tools:s,disabledPlugins:F.optional(),disabledAgentPlugins:F.optional()}).strip().transform((f)=>{let P={autoUpdateEnabled:f.autoUpdateEnabled,telemetryOptOut:f.telemetryOptOut};if(f.compactionStrategy)P.compactionStrategy=f.compactionStrategy;if(f.compactionEnabled!==void 0)P.compactionEnabled=f.compactionEnabled;if(f.planActMode)P.planActMode=f.planActMode;if(f.toolAutoApprove!==void 0)P.toolAutoApprove=f.toolAutoApprove;if(f.tuiTheme?.trim())P.tuiTheme=f.tuiTheme.trim();if(f.disabledTools?.length)P.disabledTools=f.disabledTools;if(f.tools&&Object.keys(f.tools).length>0)P.tools=f.tools;if(f.disabledPlugins?.length)P.disabledPlugins=f.disabledPlugins;if(f.disabledAgentPlugins?.length)P.disabledAgentPlugins=f.disabledAgentPlugins;return P});function Z(){return E.parse({})}var V;function t(f){if(f.disabledTools)Object.freeze(f.disabledTools);if(f.tools){for(let P of Object.values(f.tools))Object.freeze(P);Object.freeze(f.tools)}if(f.disabledPlugins)Object.freeze(f.disabledPlugins);if(f.disabledAgentPlugins)Object.freeze(f.disabledAgentPlugins);return Object.freeze(f)}function e(f){let P;try{P=l(f,"utf8")}catch{return Z()}try{let A=E.safeParse(JSON.parse(P));return A.success?A.data:Z()}catch{return Z()}}function ff(){let f=a(),P=n(f,{throwIfNoEntry:!1}),A=P?.mtimeMs??0,O=P?.size??0,j=V;if(j&&j.path===f&&j.mtimeMs===A&&j.size===O)return j;let H=t(P?e(f):Z());return V={path:f,mtimeMs:A,size:O,value:H},V}function Pf(){return ff().value}function I(){return Pf().telemetryOptOut}class U{name;logger;enabled;constructor(f={}){this.name=f.name??"TelemetryLoggerSink",this.logger=f.logger,this.enabled=f.enabled??!0}emit(f,P){if(!this.isEnabled())return;this.logger?.log("telemetry.event",{telemetrySink:this.name,event:f,properties:P})}emitRequired(f,P){this.logger?.log("telemetry.required_event",{telemetrySink:this.name,severity:"warn",event:f,properties:P})}recordCounter(f,P,A,O,j){if(!j&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"counter",name:f,value:P,attributes:A,description:O,required:j===!0})}recordHistogram(f,P,A,O,j){if(!j&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"histogram",name:f,value:P,attributes:A,description:O,required:j===!0})}recordGauge(f,P,A,O,j){if(!j&&!this.isEnabled())return;this.logger?.debug("telemetry.metric",{telemetrySink:this.name,instrument:"gauge",name:f,value:P,attributes:A,description:O,required:j===!0})}isEnabled(){return typeof this.enabled==="function"?this.enabled():this.enabled}async flush(){}async dispose(){}}class Q{adapters;metadata;distinctId;deviceId;commonProperties;constructor(f={}){if(this.adapters=[...f.adapters??[]],f.logger)this.adapters.push(new U({logger:f.logger}));this.metadata={...f.metadata??{}},this.distinctId=f.distinctId,this.deviceId=f.deviceId??R(),this.commonProperties={...f.commonProperties??{}}}addAdapter(f){this.adapters.push(f)}setDistinctId(f){this.distinctId=f}setMetadata(f){this.metadata={...f}}updateMetadata(f){this.metadata={...this.metadata,...f}}setCommonProperties(f){this.commonProperties={...f}}updateCommonProperties(f){this.commonProperties={...this.commonProperties,...f}}isEnabled(){return this.adapters.some((f)=>f.isEnabled())}capture(f){let P=this.buildAttributes(f.properties);for(let A of this.adapters)A.emit(f.event,P)}captureRequired(f,P){let A=this.buildAttributes(P);for(let O of this.adapters)O.emitRequired(f,A)}recordCounter(f,P,A,O,j=!1){let H=this.buildAttributes(A);for(let $ of this.adapters)$.recordCounter(f,P,H,O,j)}recordHistogram(f,P,A,O,j=!1){let H=this.buildAttributes(A);for(let $ of this.adapters)$.recordHistogram(f,P,H,O,j)}recordGauge(f,P,A,O,j=!1){let H=this.buildAttributes(A);for(let $ of this.adapters)$.recordGauge(f,P,H,O,j)}async flush(){await Promise.all(this.adapters.map((f)=>f.flush()))}async dispose(){await Promise.all(this.adapters.map((f)=>f.dispose()))}buildAttributes(f){return{...this.commonProperties,...f,...this.metadata,...this.distinctId?{distinct_id:this.distinctId}:{},device_id:this.deviceId}}}class z{distinctId;metadata;commonProperties;constructor(f={}){this.distinctId=f.distinctId,this.metadata={...f.metadata??{}},this.commonProperties={...f.commonProperties??{}}}setDistinctId(f){this.distinctId=f}setMetadata(f){this.metadata={...f}}updateMetadata(f){this.metadata={...this.metadata,...f}}setCommonProperties(f){this.commonProperties={...f}}updateCommonProperties(f){this.commonProperties={...this.commonProperties,...f}}isEnabled(){return!1}capture(f){this.resolveProperties(f.properties)}captureRequired(f,P){this.resolveProperties(P)}recordCounter(){}recordHistogram(){}recordGauge(){}async flush(){}async dispose(){}resolveProperties(f){return{...this.commonProperties,...f,...this.metadata,...this.distinctId?{distinct_id:this.distinctId}:{}}}}class L{meterProvider;loggerProvider;tracerProvider;options;constructor(f={}){this.options=f;let P=Jf({[Vf]:f.serviceName??"cline",...f.serviceVersion?{[Uf]:f.serviceVersion}:{}});if(this.meterProvider=this.createMeterProvider(P),this.loggerProvider=this.createLoggerProvider(P),this.tracerProvider=this.createTracerProvider(P),this.meterProvider)Af.setGlobalMeterProvider(this.meterProvider);if(this.loggerProvider)jf.setGlobalLoggerProvider(this.loggerProvider);if(this.tracerProvider)this.tracerProvider.register()}getTracer(f="cline",P){return Of.getTracer(f,P??this.options.serviceVersion)}createAdapter(f){return new Y({...f,meterProvider:this.meterProvider,loggerProvider:this.loggerProvider})}createTelemetryService(f){let P=this.createAdapter({name:f.name,enabled:this.options.enabled,metadata:f.metadata});return new Q({...f,adapters:[P],distinctId:X(f.distinctId)})}async forceFlush(){await Promise.all([this.meterProvider?.forceFlush?.(),this.loggerProvider?.forceFlush?.(),this.tracerProvider?.forceFlush?.()])}async dispose(){await Promise.all([this.meterProvider?.shutdown?.(),this.loggerProvider?.shutdown?.(),this.tracerProvider?.shutdown?.()])}createMeterProvider(f){let P=_(this.options.metricsExporter);if(P.length===0)return null;let A=Math.max(1000,this.options.metricExportIntervalMs??this.options.metricExportInterval??60000),O=Math.min(30000,Math.floor(A*0.8)),j=P.map((H)=>Mf(H,{endpoint:this.options.otlpEndpoint,headers:this.options.otlpHeaders,insecure:this.options.otlpInsecure??!1,protocol:"http/json",interval:A,timeout:O})).filter((H)=>H!==null);if(j.length===0)return null;return new Zf({resource:f,readers:j})}createTracerProvider(f){let P=_(this.options.tracesExporter);if(P.length===0)return null;let A=this.options.otlpTracesEndpoint??this.options.otlpEndpoint,O=this.options.otlpTracesHeaders??this.options.otlpHeaders,j=[];for(let H of P){let $=kf(H,{endpoint:A,headers:O,insecure:this.options.otlpInsecure??!1,protocol:"http/json"});if($)j.push($)}if(j.length===0)return null;return new Ff({resource:f,spanProcessors:j})}createLoggerProvider(f){let P=_(this.options.logsExporter);if(P.length===0)return null;let A=P.map((O)=>{let j=Lf(O,{endpoint:this.options.otlpEndpoint,headers:this.options.otlpHeaders,insecure:this.options.otlpInsecure??!1,protocol:"http/json"});if(!j)return null;return new Wf(j,{maxQueueSize:this.options.logMaxQueueSize??2048,maxExportBatchSize:this.options.logBatchSize??512,scheduledDelayMillis:this.options.logBatchTimeoutMs??this.options.logBatchTimeout??5000})}).filter((O)=>O!==null);if(A.length===0)return null;return new Xf({resource:f,processors:A})}}function D(f){let P=new L(f),A=P.createTelemetryService(f),O=()=>{A.captureRequired("telemetry.provider_created",{provider:"opentelemetry",enabled:f.enabled??!0,logsExporter:Array.isArray(f.logsExporter)?f.logsExporter.join(","):f.logsExporter,metricsExporter:Array.isArray(f.metricsExporter)?f.metricsExporter.join(","):f.metricsExporter,tracesExporter:Array.isArray(f.tracesExporter)?f.tracesExporter.join(","):f.tracesExporter,otlpProtocol:f.otlpProtocol,hasOtlpEndpoint:Boolean(f.otlpEndpoint),serviceName:f.serviceName,serviceVersion:f.serviceVersion})};if(!f.deferProviderCreatedEvent)O();return{provider:P,telemetry:A,emitProviderCreated:O}}function x(f){if(I())return{telemetry:new z(f)};if(f.enabled!==!0)return{telemetry:new Q({...f,distinctId:X(f.distinctId)})};return D(f)}function _f(f){let{telemetry:P,provider:A,emitProviderCreated:O}=x(f);return{telemetry:P,provider:A,flush:async()=>{let $=A;if($&&typeof $.forceFlush==="function")try{await $.forceFlush()}catch{}},dispose:async()=>{await Promise.allSettled([P.dispose(),A?.dispose()])},...f.deferProviderCreatedEvent&&O?{emitProviderCreated:O}:{}}}function _(f){if(!f)return[];return(Array.isArray(f)?f:f.split(",")).map((A)=>A.trim()).filter((A)=>A==="console"||A==="otlp")}function Lf(f,P){if(f==="console")return new Kf;if(!P.endpoint)return null;let A=k(P.endpoint,"/v1/logs");return new Hf({url:A,headers:P.headers})}function kf(f,P){if(f==="console")return new Rf(new Bf);if(!P.endpoint)return null;let A=k(P.endpoint,"/v1/traces");return new Qf(new $f({url:A,headers:P.headers}))}function Mf(f,P){if(f==="console")return new y({exporter:new Yf,exportIntervalMillis:P.interval,exportTimeoutMillis:P.timeout});if(!P.endpoint)return null;let A=k(P.endpoint,"/v1/metrics");return new y({exporter:new Tf({url:A,headers:P.headers}),exportIntervalMillis:P.interval,exportTimeoutMillis:P.timeout})}function k(f,P){let A=new URL(f),O=A.pathname.endsWith("/")?A.pathname.slice(0,-1):A.pathname;return A.pathname=O.endsWith(P)?O:`${O}${P}`,A.toString()}export{X as resolveCoreDistinctId,R as resolveCoreDeviceId,D as createOpenTelemetryTelemetryService,x as createConfiguredTelemetryService,_f as createConfiguredTelemetryHandle,L as OpenTelemetryProvider,Y as OpenTelemetryAdapter};