@clinebot/core 0.0.4 → 0.0.6

package/dist/runtime/session-runtime.d.ts

@@ -1,12 +1,13 @@
 import type { AgentConfig, AgentHooks, AgentResult, AgentTeamsRuntime, Tool } from "@clinebot/agents";
-import type { BasicLogger } from "@clinebot/shared";
+import type { BasicLogger, ITelemetryService } from "@clinebot/shared";
 import type { UserInstructionConfigWatcher } from "../agents";
-import type { ToolExecutors } from "../default-tools";
+import type { ToolExecutors } from "../tools";
 import type { CoreSessionConfig } from "../types/config";
 export interface BuiltRuntime {
     tools: Tool[];
     hooks?: AgentHooks;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
     teamRuntime?: AgentTeamsRuntime;
     completionGuard?: () => string | undefined;
     shutdown: (reason: string) => Promise<void> | void;
@@ -21,6 +22,7 @@ export interface RuntimeBuilderInput {
     userInstructionWatcher?: UserInstructionConfigWatcher;
     defaultToolExecutors?: Partial<ToolExecutors>;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
 }
 export interface RuntimeBuilder {
     build(input: RuntimeBuilderInput): BuiltRuntime;

package/dist/session/default-session-manager.d.ts

@@ -1,8 +1,9 @@
 import { Agent, type AgentConfig, type AgentResult, type ToolApprovalRequest, type ToolApprovalResult } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import { type ToolExecutors } from "../default-tools";
+import { type ITelemetryService } from "@clinebot/shared";
 import type { RuntimeBuilder } from "../runtime/session-runtime";
 import { ProviderSettingsManager } from "../storage/provider-settings-manager";
+import { type ToolExecutors } from "../tools";
 import type { CoreSessionEvent } from "../types/events";
 import type { SessionRecord } from "../types/sessions";
 import type { RpcCoreSessionService } from "./rpc-session-service";
@@ -19,6 +20,7 @@ export interface DefaultSessionManagerOptions {
     toolPolicies?: AgentConfig["toolPolicies"];
     providerSettingsManager?: ProviderSettingsManager;
     oauthTokenManager?: RuntimeOAuthTokenManager;
+    telemetry?: ITelemetryService;
     requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
 }
 export declare class DefaultSessionManager implements SessionManager {
@@ -29,6 +31,7 @@ export declare class DefaultSessionManager implements SessionManager {
     private readonly defaultToolPolicies?;
     private readonly providerSettingsManager;
     private readonly oauthTokenManager;
+    private readonly defaultTelemetry?;
     private readonly defaultRequestToolApproval?;
     private readonly listeners;
     private readonly sessions;
@@ -75,5 +78,6 @@ export declare class DefaultSessionManager implements SessionManager {
     private runWithAuthRetry;
     private isLikelyAuthError;
     private syncOAuthCredentials;
+    updateSessionModel(sessionId: string, modelId: string): Promise<void>;
 }
 export {};

package/dist/session/session-host.d.ts

@@ -1,5 +1,6 @@
 import type { AgentConfig, ToolApprovalRequest, ToolApprovalResult } from "@clinebot/agents";
-import type { ToolExecutors } from "../default-tools";
+import type { ITelemetryService } from "@clinebot/shared";
+import type { ToolExecutors } from "../tools";
 import { RpcCoreSessionService } from "./rpc-session-service";
 import type { SessionManager } from "./session-manager";
 import { CoreSessionService } from "./session-service";
@@ -13,6 +14,7 @@ export interface CreateSessionHostOptions {
     rpcConnectAttempts?: number;
     rpcConnectDelayMs?: number;
     defaultToolExecutors?: Partial<ToolExecutors>;
+    telemetry?: ITelemetryService;
     toolPolicies?: AgentConfig["toolPolicies"];
     requestToolApproval?: (request: ToolApprovalRequest) => Promise<ToolApprovalResult>;
 }

package/dist/session/session-manager.d.ts

@@ -15,7 +15,7 @@ export interface StartSessionInput {
     userFiles?: string[];
     userInstructionWatcher?: import("../agents").UserInstructionConfigWatcher;
     onTeamRestored?: () => void;
-    defaultToolExecutors?: Partial<import("../default-tools").ToolExecutors>;
+    defaultToolExecutors?: Partial<import("../tools").ToolExecutors>;
     toolPolicies?: import("@clinebot/agents").AgentConfig["toolPolicies"];
     requestToolApproval?: (request: import("@clinebot/agents").ToolApprovalRequest) => Promise<import("@clinebot/agents").ToolApprovalResult>;
 }
@@ -55,4 +55,5 @@ export interface SessionManager {
     readTranscript(sessionId: string, maxChars?: number): Promise<string>;
     readHooks(sessionId: string, limit?: number): Promise<unknown[]>;
     subscribe(listener: (event: CoreSessionEvent) => void): () => void;
+    updateSessionModel?(sessionId: string, modelId: string): Promise<void>;
 }

package/dist/session/unified-session-persistence-service.d.ts

@@ -12,6 +12,7 @@ export interface PersistedSessionUpdateInput {
     exitCode?: number | null;
     prompt?: string | null;
     metadataJson?: string | null;
+    title?: string | null;
     parentSessionId?: string | null;
     parentAgentId?: string | null;
     agentId?: string | null;
@@ -55,6 +56,8 @@ export declare class UnifiedSessionPersistenceService {
     private activeTeamTaskSessionId;
     private subagentArtifactPaths;
     private writeSessionManifestFile;
+    private readSessionManifestFile;
+    private applyResolvedTitleToRow;
     private createRootSessionId;
     createRootSessionWithArtifacts(input: CreateRootSessionWithArtifactsInput): Promise<RootSessionArtifacts>;
     writeSessionManifest(manifestPath: string, manifest: SessionManifest): void;
@@ -66,6 +69,7 @@ export declare class UnifiedSessionPersistenceService {
         sessionId: string;
         prompt?: string | null;
         metadata?: Record<string, unknown> | null;
+        title?: string | null;
     }): Promise<{
         updated: boolean;
     }>;

package/dist/telemetry/ITelemetryAdapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Telemetry adapter interface for the @clinebot/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 "@clinebot/shared";
+export type { TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "@clinebot/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/telemetry/LoggerTelemetryAdapter.d.ts

@@ -0,0 +1,21 @@
+import type { BasicLogger } from "@clinebot/shared";
+import type { ITelemetryAdapter, TelemetryProperties } from "./ITelemetryAdapter";
+export interface LoggerTelemetryAdapterOptions {
+    logger?: BasicLogger;
+    name?: string;
+    enabled?: boolean | (() => boolean);
+}
+export declare class LoggerTelemetryAdapter implements ITelemetryAdapter {
+    readonly name: string;
+    private readonly logger?;
+    private readonly enabled;
+    constructor(options?: LoggerTelemetryAdapterOptions);
+    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/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/telemetry/OpenTelemetryProvider.d.ts

@@ -0,0 +1,41 @@
+import type { BasicLogger, ITelemetryService, OpenTelemetryClientConfig, TelemetryMetadata } from "@clinebot/shared";
+import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
+import { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions } from "./OpenTelemetryAdapter";
+type OpenTelemetryExporterKind = "console" | "otlp";
+export interface OpenTelemetryProviderOptions extends Omit<OpenTelemetryClientConfig, "enabled" | "logsExporter" | "metricsExporter"> {
+    serviceName?: string;
+    serviceVersion?: string;
+    enabled?: boolean;
+    logsExporter?: string | OpenTelemetryExporterKind[];
+    metricsExporter?: 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;
+    private readonly options;
+    constructor(options?: OpenTelemetryProviderOptions);
+    createAdapter(options: Omit<OpenTelemetryAdapterOptions, "meterProvider" | "loggerProvider">): OpenTelemetryAdapter;
+    createTelemetryService(options: Omit<CreateOpenTelemetryTelemetryServiceOptions, keyof OpenTelemetryProviderOptions>): ITelemetryService;
+    forceFlush(): Promise<void>;
+    dispose(): Promise<void>;
+    private createMeterProvider;
+    private createLoggerProvider;
+}
+export declare function createOpenTelemetryTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+export declare function createConfiguredTelemetryService(options: CreateOpenTelemetryTelemetryServiceOptions): {
+    provider?: OpenTelemetryProvider;
+    telemetry: ITelemetryService;
+};
+export {};

package/dist/telemetry/TelemetryService.d.ts

@@ -0,0 +1,34 @@
+import type { BasicLogger, ITelemetryService, TelemetryMetadata, TelemetryProperties } from "@clinebot/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;
+}

package/dist/telemetry/opentelemetry.d.ts

@@ -0,0 +1,3 @@
+export type { ITelemetryAdapter, TelemetryArray, TelemetryMetadata, TelemetryObject, TelemetryPrimitive, TelemetryProperties, TelemetryValue, } from "./ITelemetryAdapter";
+export { OpenTelemetryAdapter, type OpenTelemetryAdapterOptions, } from "./OpenTelemetryAdapter";
+export { type CreateOpenTelemetryTelemetryServiceOptions, createConfiguredTelemetryService, createOpenTelemetryTelemetryService, OpenTelemetryProvider, type OpenTelemetryProviderOptions, } from "./OpenTelemetryProvider";