@clinebot/core 0.0.28 → 0.0.29

package/src/telemetry/OpenTelemetryProvider.test.ts

@@ -52,6 +52,29 @@ describe("createOpenTelemetryTelemetryService", () => {
 		await provider.dispose();
 	});
 
+	it("registers a tracer provider when tracesExporter is set", async () => {
+		const { provider } = createOpenTelemetryTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: true,
+			tracesExporter: "console",
+			logsExporter: "console",
+			metricsExporter: "console",
+			serviceName: "cline-test",
+		});
+
+		expect(provider.tracerProvider).not.toBeNull();
+		const span = provider.getTracer("test").startSpan("verify.tracing");
+		span.end();
+		await provider.dispose();
+	});
+
 	it("does not create an OTEL provider when disabled", () => {
 		const providerSpy = vi.spyOn(
 			OpenTelemetryProvider.prototype,
@@ -78,8 +101,7 @@ describe("createOpenTelemetryTelemetryService", () => {
 	it("attaches the logger adapter when creating configured telemetry", () => {
 		const logger: BasicLogger = {
 			debug: vi.fn(),
-			info: vi.fn(),
-			warn: vi.fn(),
+			log: vi.fn(),
 			error: vi.fn(),
 		};
 		const { telemetry, provider } = createConfiguredTelemetryService({
@@ -101,7 +123,7 @@ describe("createOpenTelemetryTelemetryService", () => {
 			properties: { sessionId: "session-1" },
 		});
 
-		expect(logger.info).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.event",
 			expect.objectContaining({
 				event: "session.started",

package/src/telemetry/OpenTelemetryProvider.ts

@@ -4,11 +4,12 @@ import type {
 	OpenTelemetryClientConfig,
 	TelemetryMetadata,
 } from "@clinebot/shared";
-import { metrics } from "@opentelemetry/api";
+import { metrics, type Tracer, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPMetricExporter as OTLPMetricExporterHttp } from "@opentelemetry/exporter-metrics-otlp-http";
-import { Resource } from "@opentelemetry/resources";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
 	BatchLogRecordProcessor,
 	ConsoleLogRecordExporter,
@@ -21,6 +22,13 @@ import {
 	type MetricReader,
 	PeriodicExportingMetricReader,
 } from "@opentelemetry/sdk-metrics";
+import {
+	BatchSpanProcessor,
+	ConsoleSpanExporter,
+	SimpleSpanProcessor,
+	type SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import {
 	ATTR_SERVICE_NAME,
 	ATTR_SERVICE_VERSION,
@@ -38,13 +46,14 @@ type OpenTelemetryProtocol = "http/json";
 export interface OpenTelemetryProviderOptions
 	extends Omit<
 		OpenTelemetryClientConfig,
-		"enabled" | "logsExporter" | "metricsExporter"
+		"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;
@@ -64,11 +73,12 @@ export interface CreateOpenTelemetryTelemetryServiceOptions
 export class OpenTelemetryProvider {
 	readonly meterProvider: MeterProvider | null;
 	readonly loggerProvider: LoggerProvider | null;
+	readonly tracerProvider: NodeTracerProvider | null;
 	private readonly options: OpenTelemetryProviderOptions;
 
 	constructor(options: OpenTelemetryProviderOptions = {}) {
 		this.options = options;
-		const resource = new Resource({
+		const resource = resourceFromAttributes({
 			[ATTR_SERVICE_NAME]: options.serviceName ?? "cline",
 			...(options.serviceVersion
 				? { [ATTR_SERVICE_VERSION]: options.serviceVersion }
@@ -77,6 +87,7 @@ export class OpenTelemetryProvider {
 
 		this.meterProvider = this.createMeterProvider(resource);
 		this.loggerProvider = this.createLoggerProvider(resource);
+		this.tracerProvider = this.createTracerProvider(resource);
 
 		if (this.meterProvider) {
 			metrics.setGlobalMeterProvider(this.meterProvider);
@@ -84,6 +95,17 @@ export class OpenTelemetryProvider {
 		if (this.loggerProvider) {
 			logs.setGlobalLoggerProvider(this.loggerProvider);
 		}
+		if (this.tracerProvider) {
+			this.tracerProvider.register();
+		}
+	}
+
+	/**
+	 * Returns a tracer for manual spans. Requires {@link OpenTelemetryProviderOptions.tracesExporter}
+	 * so that a {@link NodeTracerProvider} is registered.
+	 */
+	getTracer(name = "cline", version?: string): Tracer {
+		return trace.getTracer(name, version ?? this.options.serviceVersion);
 	}
 
 	createAdapter(
@@ -122,6 +144,7 @@ export class OpenTelemetryProvider {
 		await Promise.all([
 			this.meterProvider?.forceFlush?.(),
 			this.loggerProvider?.forceFlush?.(),
+			this.tracerProvider?.forceFlush?.(),
 		]);
 	}
 
@@ -129,10 +152,13 @@ export class OpenTelemetryProvider {
 		await Promise.all([
 			this.meterProvider?.shutdown?.(),
 			this.loggerProvider?.shutdown?.(),
+			this.tracerProvider?.shutdown?.(),
 		]);
 	}
 
-	private createMeterProvider(resource: Resource): MeterProvider | null {
+	private createMeterProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): MeterProvider | null {
 		const exporters = normalizeExporters(this.options.metricsExporter);
 		if (exporters.length === 0) {
 			return null;
@@ -168,35 +194,71 @@ export class OpenTelemetryProvider {
 		});
 	}
 
-	private createLoggerProvider(resource: Resource): LoggerProvider | null {
-		const exporters = normalizeExporters(this.options.logsExporter);
+	private createTracerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): NodeTracerProvider | null {
+		const exporters = normalizeExporters(this.options.tracesExporter);
 		if (exporters.length === 0) {
 			return null;
 		}
 
-		const provider = new LoggerProvider({ resource });
+		const traceEndpoint =
+			this.options.otlpTracesEndpoint ?? this.options.otlpEndpoint;
+		const traceHeaders =
+			this.options.otlpTracesHeaders ?? this.options.otlpHeaders;
+
+		const processors: SpanProcessor[] = [];
 		for (const exporter of exporters) {
-			const logExporter = createLogExporter(exporter, {
-				endpoint: this.options.otlpEndpoint,
-				headers: this.options.otlpHeaders,
+			const processor = createSpanProcessor(exporter, {
+				endpoint: traceEndpoint,
+				headers: traceHeaders,
 				insecure: this.options.otlpInsecure ?? false,
 				protocol: "http/json",
 			});
-			if (!logExporter) {
-				continue;
+			if (processor) {
+				processors.push(processor);
 			}
-			provider.addLogRecordProcessor(
-				new BatchLogRecordProcessor(logExporter, {
+		}
+		if (processors.length === 0) {
+			return null;
+		}
+
+		return new NodeTracerProvider({ resource, spanProcessors: processors });
+	}
+
+	private createLoggerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): LoggerProvider | null {
+		const exporters = normalizeExporters(this.options.logsExporter);
+		if (exporters.length === 0) {
+			return null;
+		}
+
+		const processors = exporters
+			.map((exporter) => {
+				const logExporter = createLogExporter(exporter, {
+					endpoint: this.options.otlpEndpoint,
+					headers: this.options.otlpHeaders,
+					insecure: this.options.otlpInsecure ?? false,
+					protocol: "http/json",
+				});
+				if (!logExporter) {
+					return null;
+				}
+				return new BatchLogRecordProcessor(logExporter, {
 					maxQueueSize: this.options.logMaxQueueSize ?? 2048,
 					maxExportBatchSize: this.options.logBatchSize ?? 512,
 					scheduledDelayMillis:
 						this.options.logBatchTimeoutMs ??
 						this.options.logBatchTimeout ??
 						5000,
-				}),
-			);
+				});
+			})
+			.filter((p): p is BatchLogRecordProcessor => p !== null);
+		if (processors.length === 0) {
+			return null;
 		}
-		return provider;
+		return new LoggerProvider({ resource, processors });
 	}
 }
 
@@ -214,6 +276,9 @@ export function createOpenTelemetryTelemetryService(
 		metricsExporter: Array.isArray(options.metricsExporter)
 			? options.metricsExporter.join(",")
 			: options.metricsExporter,
+		tracesExporter: Array.isArray(options.tracesExporter)
+			? options.tracesExporter.join(",")
+			: options.tracesExporter,
 		otlpProtocol: options.otlpProtocol,
 		hasOtlpEndpoint: Boolean(options.otlpEndpoint),
 		serviceName: options.serviceName,
@@ -280,6 +345,31 @@ function createLogExporter(
 	});
 }
 
+function createSpanProcessor(
+	exporter: OpenTelemetryExporterKind,
+	options: {
+		endpoint?: string;
+		headers?: Record<string, string>;
+		insecure: boolean;
+		protocol: OpenTelemetryProtocol;
+	},
+): SpanProcessor | null {
+	if (exporter === "console") {
+		return new SimpleSpanProcessor(new ConsoleSpanExporter());
+	}
+	if (!options.endpoint) {
+		return null;
+	}
+
+	const endpoint = ensurePathSuffix(options.endpoint, "/v1/traces");
+	return new BatchSpanProcessor(
+		new OTLPTraceExporter({
+			url: endpoint,
+			headers: options.headers,
+		}),
+	);
+}
+
 function createMetricReader(
 	exporter: OpenTelemetryExporterKind,
 	options: {

package/src/telemetry/TelemetryLoggerSink.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
+
+describe("TelemetryLoggerSink", () => {
+	it("logs events and metrics through the provided logger", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+		};
+		const sink = new TelemetryLoggerSink({ logger });
+
+		sink.emit("session.started", { sessionId: "s1" });
+		sink.emitRequired("user.opt_out", { reason: "manual" });
+		sink.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "s1",
+		});
+
+		expect(logger.log).toHaveBeenCalledWith("telemetry.event", {
+			telemetrySink: "TelemetryLoggerSink",
+			event: "session.started",
+			properties: { sessionId: "s1" },
+		});
+		expect(logger.log).toHaveBeenCalledWith("telemetry.required_event", {
+			telemetrySink: "TelemetryLoggerSink",
+			severity: "warn",
+			event: "user.opt_out",
+			properties: { reason: "manual" },
+		});
+		expect(logger.debug).toHaveBeenCalledWith("telemetry.metric", {
+			telemetrySink: "TelemetryLoggerSink",
+			instrument: "counter",
+			name: "cline.session.starts.total",
+			value: 1,
+			attributes: { sessionId: "s1" },
+			description: undefined,
+			required: false,
+		});
+
+		await sink.flush();
+		await sink.dispose();
+	});
+});

package/src/telemetry/{LoggerTelemetryAdapter.ts → TelemetryLoggerSink.ts}

@@ -4,20 +4,26 @@ import type {
 	TelemetryProperties,
 } from "./ITelemetryAdapter";
 
-export interface LoggerTelemetryAdapterOptions {
+/**
+ * {@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 class LoggerTelemetryAdapter implements ITelemetryAdapter {
+export class TelemetryLoggerSink implements ITelemetryAdapter {
 	readonly name: string;
 
 	private readonly logger?: BasicLogger;
 	private readonly enabled: boolean | (() => boolean);
 
-	constructor(options: LoggerTelemetryAdapterOptions = {}) {
-		this.name = options.name ?? "LoggerTelemetryAdapter";
+	constructor(options: TelemetryLoggerSinkOptions = {}) {
+		this.name = options.name ?? "TelemetryLoggerSink";
 		this.logger = options.logger;
 		this.enabled = options.enabled ?? true;
 	}
@@ -26,16 +32,17 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!this.isEnabled()) {
 			return;
 		}
-		this.logger?.info?.("telemetry.event", {
-			adapter: this.name,
+		this.logger?.log("telemetry.event", {
+			telemetrySink: this.name,
 			event,
 			properties,
 		});
 	}
 
 	emitRequired(event: string, properties?: TelemetryProperties): void {
-		this.logger?.warn?.("telemetry.required_event", {
-			adapter: this.name,
+		this.logger?.log("telemetry.required_event", {
+			telemetrySink: this.name,
+			severity: "warn",
 			event,
 			properties,
 		});
@@ -51,8 +58,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "counter",
 			name,
 			value,
@@ -72,8 +79,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "histogram",
 			name,
 			value,
@@ -93,8 +100,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "gauge",
 			name,
 			value,

package/src/telemetry/TelemetryService.test.ts

@@ -53,8 +53,7 @@ describe("TelemetryService", () => {
 	it("mirrors telemetry events into the logger when provided", () => {
 		const logger: BasicLogger = {
 			debug: vi.fn(),
-			info: vi.fn(),
-			warn: vi.fn(),
+			log: vi.fn(),
 			error: vi.fn(),
 		};
 		const service = new TelemetryService({
@@ -75,10 +74,10 @@ describe("TelemetryService", () => {
 			sessionId: "session-1",
 		});
 
-		expect(logger.info).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.event",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
 				event: "session.started",
 				properties: expect.objectContaining({
 					sessionId: "session-1",
@@ -87,10 +86,11 @@ describe("TelemetryService", () => {
 				}),
 			}),
 		);
-		expect(logger.warn).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.required_event",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
+				severity: "warn",
 				event: "user.opt_out",
 				properties: expect.objectContaining({
 					reason: "manual",
@@ -101,7 +101,7 @@ describe("TelemetryService", () => {
 		expect(logger.debug).toHaveBeenCalledWith(
 			"telemetry.metric",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
 				instrument: "counter",
 				name: "cline.session.starts.total",
 			}),

package/src/telemetry/TelemetryService.ts

@@ -5,7 +5,7 @@ import type {
 	TelemetryProperties,
 } from "@clinebot/shared";
 import type { ITelemetryAdapter } from "./ITelemetryAdapter";
-import { LoggerTelemetryAdapter } from "./LoggerTelemetryAdapter";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
 
 export interface TelemetryServiceOptions {
 	adapters?: ITelemetryAdapter[];
@@ -24,9 +24,7 @@ export class TelemetryService implements ITelemetryService {
 	constructor(options: TelemetryServiceOptions = {}) {
 		this.adapters = [...(options.adapters ?? [])];
 		if (options.logger) {
-			this.adapters.push(
-				new LoggerTelemetryAdapter({ logger: options.logger }),
-			);
+			this.adapters.push(new TelemetryLoggerSink({ logger: options.logger }));
 		}
 		this.metadata = { ...(options.metadata ?? {}) };
 		this.distinctId = options.distinctId;

package/src/tools/definitions.test.ts

@@ -187,6 +187,82 @@ describe("default ask_question tool", () => {
 	});
 });
 
+describe("default submit_and_exit tool", () => {
+	it("is excluded by default even when executor is provided", () => {
+		const tools = createDefaultTools({
+			executors: {
+				submit: async () => "ok",
+			},
+		});
+		expect(tools.map((tool) => tool.name)).not.toContain("submit_and_exit");
+	});
+
+	it("is included only when enabled with a submit executor", () => {
+		const toolsWithoutExecutor = createDefaultTools({
+			executors: {},
+			enableSubmitAndExit: true,
+		});
+		expect(toolsWithoutExecutor.map((tool) => tool.name)).not.toContain(
+			"submit_and_exit",
+		);
+
+		const toolsWithExecutor = createDefaultTools({
+			executors: {
+				submit: async () => "ok",
+			},
+			enableSubmitAndExit: true,
+		});
+		expect(toolsWithExecutor.map((tool) => tool.name)).toContain(
+			"submit_and_exit",
+		);
+	});
+
+	it("validates and executes submit_and_exit input", async () => {
+		const execute = vi.fn(async () => "submitted");
+		const tools = createDefaultTools({
+			executors: {
+				submit: execute,
+			},
+			enableReadFiles: false,
+			enableSearch: false,
+			enableBash: false,
+			enableWebFetch: false,
+			enableEditor: false,
+			enableSkills: false,
+			enableAskQuestion: false,
+			enableSubmitAndExit: true,
+		});
+		const submitTool = tools.find((tool) => tool.name === "submit_and_exit");
+		expect(submitTool).toBeDefined();
+		if (!submitTool) {
+			throw new Error("Expected submit_and_exit tool to be defined.");
+		}
+
+		const result = await submitTool.execute(
+			{
+				summary: "Done and verified with the requested checks.",
+				verified: true,
+			},
+			{
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			},
+		);
+
+		expect(result).toBe("submitted");
+		expect(execute).toHaveBeenCalledWith(
+			"Done and verified with the requested checks.",
+			true,
+			expect.objectContaining({
+				agentId: "agent-1",
+				conversationId: "conv-1",
+				iteration: 1,
+			}),
+		);
+	});
+});
+
 describe("default apply_patch tool", () => {
 	it("is included only when enabled with an applyPatch executor", () => {
 		const toolsWithoutExecutor = createDefaultTools({

package/src/tools/definitions.ts

@@ -4,8 +4,12 @@
  * Factory functions for creating the default tools.
  */
 
-import { createTool, type Tool } from "@clinebot/agents";
-import { validateWithZod, zodToJsonSchema } from "@clinebot/shared";
+import {
+	createTool,
+	type Tool,
+	validateWithZod,
+	zodToJsonSchema,
+} from "@clinebot/shared";
 import {
 	formatError,
 	formatReadFileQuery,
@@ -37,6 +41,8 @@ import {
 	SkillsInputSchema,
 	type StructuredCommandInput,
 	StructuredCommandsInputUnionSchema,
+	type SubmitInput,
+	SubmitInputSchema,
 } from "./schemas";
 import type {
 	ApplyPatchExecutor,
@@ -49,6 +55,7 @@ import type {
 	SearchExecutor,
 	SkillsExecutorWithMetadata,
 	ToolOperationResult,
+	VerifySubmitExecutor,
 	WebFetchExecutor,
 } from "./types";
 
@@ -603,6 +610,34 @@ export function createAskQuestionTool(
 	});
 }
 
+export function createSubmitAndExitTool(
+	executor: VerifySubmitExecutor,
+	config: Pick<DefaultToolsConfig, "submitTimeoutMs"> = {},
+): Tool<SubmitInput, string> {
+	const timeoutMs = config.submitTimeoutMs ?? 15000;
+
+	return createTool<SubmitInput, string>({
+		name: "submit_and_exit",
+		description:
+			"Submit the final answer and exit the conversation. " +
+			"For example, submit a summary of the investigation and confirm the issue is resolved. " +
+			"You should only submit once all necessary steps are completed. " +
+			"Provide a summary of the investigation and confirm the issue is resolved.",
+		inputSchema: zodToJsonSchema(SubmitInputSchema),
+		timeoutMs,
+		retryable: false,
+		maxRetries: 0,
+		execute: async (input, context) => {
+			const validatedInput = validateWithZod(SubmitInputSchema, input);
+			return withTimeout(
+				executor(validatedInput.summary, validatedInput.verified, context),
+				timeoutMs,
+				`submit_and_exit timed out after ${timeoutMs}ms`,
+			);
+		},
+	});
+}
+
 // =============================================================================
 // Default Tools Factory
 // =============================================================================
@@ -657,6 +692,7 @@ export function createDefaultTools(options: CreateDefaultToolsOptions): Tool[] {
 		enableEditor = true,
 		enableSkills = true,
 		enableAskQuestion = true,
+		enableSubmitAndExit = false,
 		...config
 	} = options;
 
@@ -703,6 +739,9 @@ export function createDefaultTools(options: CreateDefaultToolsOptions): Tool[] {
 	// Add ask_question tool if enabled and executor provided
 	if (enableAskQuestion && executors.askQuestion) {
 		tools.push(createAskQuestionTool(executors.askQuestion, config));
+	} else if (enableSubmitAndExit && executors.submit) {
+		// Add submit_and_exit tool if enabled and executor provided
+		tools.push(createSubmitAndExitTool(executors.submit, config));
 	}
 
 	return tools;

package/src/tools/executors/apply-patch.ts

@@ -6,7 +6,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
+import type { ToolContext } from "@clinebot/shared";
 import type { ApplyPatchInput } from "../schemas";
 import type { ApplyPatchExecutor } from "../types";
 import {

package/src/tools/executors/editor.ts

@@ -6,7 +6,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
+import type { ToolContext } from "@clinebot/shared";
 import type { EditFileInput } from "../schemas";
 import type { EditorExecutor } from "../types";
 

package/src/tools/executors/file-read.ts

@@ -6,7 +6,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
+import type { ToolContext } from "@clinebot/shared";
 import type { ReadFileRequest } from "../schemas";
 import type { FileReadExecutor } from "../types";
 

package/src/tools/executors/search.ts

@@ -6,7 +6,7 @@
 
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import type { ToolContext } from "@clinebot/agents";
+import type { ToolContext } from "@clinebot/shared";
 import { getFileIndex } from "../../input";
 import type { SearchExecutor } from "../types";
 

package/src/tools/executors/web-fetch.ts

@@ -4,7 +4,7 @@
  * Built-in implementation for fetching web content using native fetch.
  */
 
-import type { ToolContext } from "@clinebot/agents";
+import type { ToolContext } from "@clinebot/shared";
 import type { WebFetchExecutor } from "../types";
 
 /**