@clinebot/core 0.0.29 → 0.0.30

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@clinebot/core",
 	"description": "Cline Core SDK for Node Runtime",
-	"version": "0.0.29",
+	"version": "0.0.30",
 	"type": "module",
 	"types": "./dist/index.d.ts",
 	"main": "./dist/index.js",
@@ -36,8 +36,8 @@
 		"test:watch": "vitest --config vitest.config.ts"
 	},
 	"dependencies": {
-		"@clinebot/agents": "0.0.29",
-		"@clinebot/llms": "0.0.29",
+		"@clinebot/agents": "0.0.30",
+		"@clinebot/llms": "0.0.30",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/api-logs": "^0.214.0",
 		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
@@ -58,7 +58,7 @@
 	},
 	"devDependencies": {
 		"@clinebot/rpc": "0.0.28",
-		"@clinebot/shared": "0.0.29"
+		"@clinebot/shared": "0.0.30"
 	},
 	"engines": {
 		"node": ">=22"

package/src/runtime/checkpoint-hooks.test.ts

@@ -30,7 +30,8 @@ async function createGitRepo(): Promise<string> {
 	return cwd;
 }
 
-describe("createCheckpointHooks", () => {
+// Currently disabled for process?.env?.CLINE_CHECKPOINT
+describe.skip("createCheckpointHooks", () => {
 	it("creates one checkpoint at the start of each root run and appends metadata", async () => {
 		const cwd = await createGitRepo();
 		let metadata: Record<string, unknown> | undefined;

package/src/session/default-session-manager.ts

@@ -344,6 +344,7 @@ export class DefaultSessionManager implements SessionManager {
 			onConsecutiveMistakeLimitReached:
 				configWithProvider.onConsecutiveMistakeLimitReached,
 			completionGuard: runtime.completionGuard,
+			consumePendingUserMessage: () => this.consumeSteerMessage(sessionId),
 			logger: runtime.logger ?? configWithProvider.logger,
 			extensionContext: configWithProvider.extensionContext,
 			onEvent: (event: AgentEvent) =>
@@ -964,6 +965,27 @@ export class DefaultSessionManager implements SessionManager {
 		});
 	}
 
+	/**
+	 * Consume the first steer-delivery pending prompt for injection into the
+	 * running agent loop. Called synchronously by the agent between iterations.
+	 */
+	private consumeSteerMessage(sessionId: string): string | undefined {
+		const session = this.sessions.get(sessionId);
+		if (!session) {
+			return undefined;
+		}
+		const steerIndex = session.pendingPrompts.findIndex(
+			(entry) => entry.delivery === "steer",
+		);
+		if (steerIndex < 0) {
+			return undefined;
+		}
+		const [steer] = session.pendingPrompts.splice(steerIndex, 1);
+		this.emitPendingPrompts(session);
+		this.emitPendingPromptSubmitted(session, steer);
+		return steer.prompt;
+	}
+
 	private enqueuePendingPrompt(
 		sessionId: string,
 		entry: {

package/src/telemetry/OpenTelemetryAdapter.ts

@@ -229,8 +229,8 @@ export class OpenTelemetryAdapter implements ITelemetryAdapter {
 	): TelemetryProperties {
 		return {
 			...this.commonProperties,
-			...properties,
 			...this.metadata,
+			...properties,
 			...(this.distinctId ? { distinct_id: this.distinctId } : {}),
 			...(required ? { _required: true } : {}),
 		};

package/src/telemetry/OpenTelemetryProvider.test.ts

@@ -98,6 +98,197 @@ describe("createOpenTelemetryTelemetryService", () => {
 		expect(telemetry).toBeInstanceOf(TelemetryService);
 	});
 
+	it("preserves metadata when disabled", () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata,
+			enabled: false,
+		});
+		const spy = vi.fn();
+		(telemetry as any).adapters.push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+	});
+
+	it("preserves metadata in the enabled (OTEL) path", async () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry, provider } = createOpenTelemetryTelemetryService({
+			metadata,
+			enabled: true,
+			logsExporter: "console",
+		});
+		const spy = vi.fn();
+		(telemetry as any).adapters.push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+		await provider.dispose();
+	});
+
+	it("delivers metadata to the OTEL logger without duplication", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		// Replace the loggerProvider with a mock so we can inspect emit calls
+		(provider as any).loggerProvider = {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		};
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		telemetry.captureRequired("test.otel_event", { custom_prop: "value" });
+
+		expect(otelEmit).toHaveBeenCalledTimes(1);
+		const emittedAttributes = otelEmit.mock.calls[0][0].attributes;
+
+		// Metadata fields must be present
+		expect(emittedAttributes).toMatchObject({
+			cline_type: "kanban",
+			platform: "kanban",
+			extension_version: "1.0.0",
+			custom_prop: "value",
+		});
+
+		// Verify no key appears more than once (flattened object can't have
+		// duplicate keys, but this guards against nested duplication patterns
+		// like metadata appearing under a sub-prefix)
+		const keys = Object.keys(emittedAttributes);
+		const metadataKeys = Object.keys(metadata);
+		for (const mk of metadataKeys) {
+			const occurrences = keys.filter((k) => k === mk || k.endsWith(`.${mk}`));
+			expect(
+				occurrences,
+				`metadata key "${mk}" should appear exactly once, found: ${occurrences.join(", ")}`,
+			).toHaveLength(1);
+		}
+
+		await provider.dispose();
+	});
+
+	it("propagates updateMetadata to OTEL logger output", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		(provider as any).loggerProvider = {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		};
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		// Update metadata after construction
+		telemetry.updateMetadata({ cline_type: "kanban-updated" });
+
+		telemetry.captureRequired("test.updated_event", {});
+
+		// The OTEL logger should see the updated value
+		const emittedAttributes =
+			otelEmit.mock.calls[otelEmit.mock.calls.length - 1][0].attributes;
+		expect(emittedAttributes.cline_type).toBe("kanban-updated");
+
+		await provider.dispose();
+	});
+
+	it("preserves logger when disabled", () => {
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.0.0",
+				cline_type: "kanban",
+				platform: "kanban",
+				platform_version: "v22.0.0",
+				os_type: "darwin",
+				os_version: "15.0",
+			},
+			enabled: false,
+			logger,
+		});
+
+		telemetry.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.event",
+			expect.objectContaining({
+				event: "session.started",
+			}),
+		);
+	});
+
 	it("attaches the logger adapter when creating configured telemetry", () => {
 		const logger: BasicLogger = {
 			debug: vi.fn(),

package/src/telemetry/OpenTelemetryProvider.ts

@@ -133,10 +133,9 @@ export class OpenTelemetryProvider {
 			metadata: options.metadata,
 		});
 		return new TelemetryService({
+			...options,
 			adapters: [adapter],
 			distinctId: resolveCoreDistinctId(options.distinctId),
-			commonProperties: options.commonProperties,
-			logger: options.logger,
 		});
 	}
 
@@ -299,6 +298,7 @@ export function createConfiguredTelemetryService(
 	if (options.enabled !== true) {
 		return {
 			telemetry: new TelemetryService({
+				...options,
 				distinctId: resolveCoreDistinctId(options.distinctId),
 			}),
 		};