@clinebot/core 0.0.5 → 0.0.7

package/dist/tools/schemas.d.ts

@@ -23,6 +23,12 @@ export declare const ReadFilesInputUnionSchema: z.ZodUnion<readonly [z.ZodObject
 export declare const SearchCodebaseInputSchema: z.ZodObject<{
     queries: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Union schema for search_codebase tool input, allowing either a single string, an array of strings, or the full object schema
+ */
+export declare const SearchCodebaseUnionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    queries: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodArray<z.ZodString>, z.ZodString]>;
 /**
  * Schema for run_commands tool input
  */
@@ -55,15 +61,9 @@ export declare const FetchWebContentInputSchema: z.ZodObject<{
  * Schema for editor tool input
  */
 export declare const EditFileInputSchema: z.ZodObject<{
-    command: z.ZodEnum<{
-        create: "create";
-        str_replace: "str_replace";
-        insert: "insert";
-    }>;
     path: z.ZodString;
-    file_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    old_str: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    new_str: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    old_text: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    new_text: z.ZodString;
     insert_line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 /**

package/dist/types/config.d.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig, AgentHooks, ConsecutiveMistakeLimitContext, ConsecutiveMistakeLimitDecision, HookErrorMode, TeamEvent, Tool } from "@clinebot/agents";
 import type { providers as LlmsProviders } from "@clinebot/llms";
-import type { AgentMode, BasicLogger, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
+import type { AgentMode, BasicLogger, ITelemetryService, SessionExecutionConfig, SessionPromptConfig, SessionWorkspaceConfig } from "@clinebot/shared";
 import type { ToolRoutingRule } from "../tools/model-tool-routing.js";
 export type CoreAgentMode = AgentMode;
 export interface CoreModelConfig {
@@ -35,6 +35,7 @@ export interface CoreSessionConfig extends CoreModelConfig, CoreRuntimeFeatures,
     hooks?: AgentHooks;
     hookErrorMode?: HookErrorMode;
     logger?: BasicLogger;
+    telemetry?: ITelemetryService;
     extraTools?: Tool[];
     pluginPaths?: string[];
     extensions?: AgentConfig["extensions"];

package/dist/types/events.d.ts

@@ -11,7 +11,7 @@ export interface SessionEndedEvent {
 }
 export interface SessionToolEvent {
     sessionId: string;
-    hookEventName: "tool_call" | "tool_result" | "agent_end" | "session_shutdown";
+    hookEventName: "tool_call" | "tool_result" | "agent_end" | "agent_error" | "session_shutdown";
     agentId?: string;
     conversationId?: string;
     parentAgentId?: string;

package/package.json

@@ -1,10 +1,18 @@
 {
 	"name": "@clinebot/core",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"main": "./dist/index.node.js",
 	"dependencies": {
-		"@clinebot/agents": "0.0.5",
-		"@clinebot/llms": "0.0.5",
+		"@clinebot/agents": "0.0.7",
+		"@clinebot/llms": "0.0.7",
+		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.56.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.56.0",
+		"@opentelemetry/exporter-metrics-otlp-http": "^0.56.0",
+		"@opentelemetry/resources": "^1.30.1",
+		"@opentelemetry/sdk-logs": "^0.56.0",
+		"@opentelemetry/sdk-metrics": "^1.30.1",
+		"@opentelemetry/semantic-conventions": "^1.37.0",
 		"better-sqlite3": "^11.10.0",
 		"nanoid": "^5.1.7",
 		"simple-git": "^3.32.3",
@@ -21,6 +29,11 @@
 			"development": "./src/index.node.ts",
 			"types": "./dist/index.node.d.ts",
 			"import": "./dist/index.node.js"
+		},
+		"./telemetry/opentelemetry": {
+			"development": "./src/telemetry/opentelemetry.ts",
+			"types": "./dist/telemetry/opentelemetry.d.ts",
+			"import": "./dist/telemetry/opentelemetry.js"
 		}
 	},
 	"description": "State-aware orchestration for Cline Agent runtimes",

package/src/agents/hooks-config-loader.ts

@@ -20,6 +20,7 @@ export enum HookConfigFileName {
 	TaskResume = "TaskResume",
 	TaskCancel = "TaskCancel",
 	TaskComplete = "TaskComplete",
+	TaskError = "TaskError",
 	PreToolUse = "PreToolUse",
 	PostToolUse = "PostToolUse",
 	UserPromptSubmit = "UserPromptSubmit",
@@ -34,6 +35,7 @@ export const HOOK_CONFIG_FILE_EVENT_MAP: Readonly<
 	[HookConfigFileName.TaskResume]: "agent_resume",
 	[HookConfigFileName.TaskCancel]: "agent_abort",
 	[HookConfigFileName.TaskComplete]: "agent_end",
+	[HookConfigFileName.TaskError]: "agent_error",
 	[HookConfigFileName.PreToolUse]: "tool_call",
 	[HookConfigFileName.PostToolUse]: "tool_result",
 	[HookConfigFileName.UserPromptSubmit]: "prompt_submit",
@@ -45,10 +47,28 @@ const HOOK_CONFIG_FILE_LOOKUP = new Map<string, HookConfigFileName>(
 	Object.values(HookConfigFileName).map((name) => [name.toLowerCase(), name]),
 );
 
+const SUPPORTED_HOOK_FILE_EXTENSIONS = new Set([
+	"",
+	".sh",
+	".bash",
+	".zsh",
+	".js",
+	".mjs",
+	".cjs",
+	".ts",
+	".mts",
+	".cts",
+	".py",
+]);
+
 export function toHookConfigFileName(
 	fileName: string,
 ): HookConfigFileName | undefined {
-	const key = basename(fileName, extname(fileName)).trim().toLowerCase();
+	const extension = extname(fileName).toLowerCase();
+	if (!SUPPORTED_HOOK_FILE_EXTENSIONS.has(extension)) {
+		return undefined;
+	}
+	const key = basename(fileName, extension).trim().toLowerCase();
 	return HOOK_CONFIG_FILE_LOOKUP.get(key);
 }
 

package/src/index.node.ts

@@ -100,6 +100,9 @@ export {
 	OCI_HEADER_OPC_REQUEST_ID,
 	refreshOcaToken,
 } from "./auth/oca";
+export async function loadOpenTelemetryAdapter() {
+	return import("./telemetry/opentelemetry.js");
+}
 export { startLocalOAuthServer } from "./auth/server";
 export type {
 	OAuthCredentials,
@@ -167,6 +170,10 @@ export {
 } from "./runtime/workflows";
 export { DefaultSessionManager } from "./session/default-session-manager";
 export { RpcCoreSessionService } from "./session/rpc-session-service";
+export {
+	type RpcSpawnLease,
+	tryAcquireRpcSpawnLease,
+} from "./session/rpc-spawn-lease";
 export {
 	deriveSubsessionStatus,
 	makeSubSessionId,

package/src/index.ts

@@ -19,6 +19,7 @@ export type {
 	BasicLogger,
 	ConnectorHookEvent,
 	HookSessionContext,
+	ITelemetryService,
 	RpcAddProviderActionRequest,
 	RpcChatMessage,
 	RpcChatRunTurnRequest,
@@ -38,6 +39,12 @@ export type {
 	RpcSaveProviderSettingsActionRequest,
 	SessionLineage,
 	TeamProgressProjectionEvent,
+	TelemetryArray,
+	TelemetryMetadata,
+	TelemetryObject,
+	TelemetryPrimitive,
+	TelemetryProperties,
+	TelemetryValue,
 	ToolPolicy,
 } from "@clinebot/shared";
 export {
@@ -116,6 +123,15 @@ export {
 	buildTeamProgressSummary,
 	toTeamProgressLifecycleEvent,
 } from "./team";
+export type { ITelemetryAdapter } from "./telemetry/ITelemetryAdapter";
+export {
+	LoggerTelemetryAdapter,
+	type LoggerTelemetryAdapterOptions,
+} from "./telemetry/LoggerTelemetryAdapter";
+export {
+	TelemetryService,
+	type TelemetryServiceOptions,
+} from "./telemetry/TelemetryService";
 export {
 	ALL_DEFAULT_TOOL_NAMES,
 	type AskQuestionExecutor,

package/src/input/file-indexer.test.ts

@@ -84,4 +84,44 @@ describe("file indexer", () => {
 			await rm(cwd, { recursive: true, force: true });
 		}
 	});
+
+	it("evicts stale workspace indexes after 10 minutes when multiple workspaces exist", async () => {
+		vi.useFakeTimers();
+		const firstWorkspace = await createTempWorkspace();
+		const secondWorkspace = await createTempWorkspace();
+		try {
+			await writeFile(
+				path.join(firstWorkspace, "first.ts"),
+				"export const first = 1\n",
+				"utf8",
+			);
+			await writeFile(
+				path.join(secondWorkspace, "second.ts"),
+				"export const second = 2\n",
+				"utf8",
+			);
+
+			const firstIndex = await getFileIndex(firstWorkspace, { ttlMs: 60_000 });
+			expect(firstIndex.has("first.ts")).toBe(true);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			vi.advanceTimersByTime(10 * 60_000 + 1);
+
+			await getFileIndex(secondWorkspace, { ttlMs: 60_000 });
+			await writeFile(
+				path.join(firstWorkspace, "later.ts"),
+				"export const later = 3\n",
+				"utf8",
+			);
+
+			const rebuiltFirstIndex = await getFileIndex(firstWorkspace, {
+				ttlMs: 60_000,
+			});
+			expect(rebuiltFirstIndex.has("later.ts")).toBe(true);
+		} finally {
+			vi.useRealTimers();
+			await rm(firstWorkspace, { recursive: true, force: true });
+			await rm(secondWorkspace, { recursive: true, force: true });
+		}
+	});
 });

package/src/input/file-indexer.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { isMainThread, parentPort, Worker } from "node:worker_threads";
 
 const DEFAULT_INDEX_TTL_MS = 15_000;
+const STALE_CACHE_EVICTION_MS = 10 * 60_000;
 const WORKER_INDEX_REQUEST_TIMEOUT_MS = 1_000;
 const DEFAULT_EXCLUDE_DIRS = new Set([
 	".git",
@@ -21,6 +22,7 @@ const DEFAULT_EXCLUDE_DIRS = new Set([
 interface CacheEntry {
 	files: Set<string>;
 	lastBuiltAt: number;
+	lastAccessedAt: number;
 	pending: Promise<Set<string>> | null;
 }
 
@@ -43,6 +45,20 @@ interface IndexResponseMessage {
 
 const CACHE = new Map<string, CacheEntry>();
 
+function pruneStaleCacheEntries(now: number): void {
+	if (CACHE.size <= 1) {
+		return;
+	}
+	for (const [cwd, entry] of CACHE.entries()) {
+		if (entry.pending) {
+			continue;
+		}
+		if (now - entry.lastAccessedAt > STALE_CACHE_EVICTION_MS) {
+			CACHE.delete(cwd);
+		}
+	}
+}
+
 function toPosixRelative(cwd: string, absolutePath: string): string {
 	return path.relative(cwd, absolutePath).split(path.sep).join("/");
 }
@@ -265,6 +281,7 @@ export async function getFileIndex(
 ): Promise<Set<string>> {
 	const ttlMs = options.ttlMs ?? DEFAULT_INDEX_TTL_MS;
 	const now = Date.now();
+	pruneStaleCacheEntries(now);
 	const existing = CACHE.get(cwd);
 
 	if (
@@ -273,10 +290,12 @@ export async function getFileIndex(
 		now - existing.lastBuiltAt <= ttlMs &&
 		existing.files.size > 0
 	) {
+		existing.lastAccessedAt = now;
 		return existing.files;
 	}
 
 	if (existing?.pending) {
+		existing.lastAccessedAt = now;
 		return existing.pending;
 	}
 
@@ -284,6 +303,7 @@ export async function getFileIndex(
 		CACHE.set(cwd, {
 			files,
 			lastBuiltAt: Date.now(),
+			lastAccessedAt: Date.now(),
 			pending: null,
 		});
 		return files;
@@ -292,6 +312,7 @@ export async function getFileIndex(
 	CACHE.set(cwd, {
 		files: existing?.files ?? new Set<string>(),
 		lastBuiltAt: existing?.lastBuiltAt ?? 0,
+		lastAccessedAt: now,
 		pending,
 	});
 

package/src/runtime/hook-file-hooks.test.ts

@@ -1,9 +1,30 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { describe, expect, it } from "vitest";
 import { createHookConfigFileHooks } from "./hook-file-hooks";
 
+async function waitForFile(
+	filePath: string,
+	timeoutMs = 1500,
+): Promise<string> {
+	const started = Date.now();
+	for (;;) {
+		try {
+			return await readFile(filePath, "utf8");
+		} catch (error) {
+			const code =
+				error && typeof error === "object" && "code" in error
+					? String((error as { code?: unknown }).code)
+					: undefined;
+			if (code !== "ENOENT" || Date.now() - started >= timeoutMs) {
+				throw error;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+	}
+}
+
 async function createWorkspaceWithHook(
 	fileName: string,
 	body: string,
@@ -17,6 +38,22 @@ async function createWorkspaceWithHook(
 }
 
 describe("createHookConfigFileHooks", () => {
+	it("ignores example hook files", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.example",
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"should-not-run"}\'\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks).toBeUndefined();
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
 	it("executes extensionless legacy hook files via bash fallback", async () => {
 		const { workspace } = await createWorkspaceWithHook(
 			"PreToolUse",
@@ -103,4 +140,64 @@ describe("createHookConfigFileHooks", () => {
 			await rm(workspace, { recursive: true, force: true });
 		}
 	});
+
+	it("executes python hook files", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.py",
+			'print(\'HOOK_CONTROL\\t{"cancel": false, "context": "python-ok"}\')\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.onToolCallStart).toBeTypeOf("function");
+			const control = await hooks?.onToolCallStart?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 1,
+				call: {
+					id: "call_1",
+					name: "read_file",
+					input: { path: "README.md" },
+				},
+			});
+			expect(control).toMatchObject({
+				cancel: false,
+				context: "python-ok",
+			});
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("maps TaskError hook files to agent_error stop events", async () => {
+		const outputPath = join(tmpdir(), `hooks-task-error-${Date.now()}.json`);
+		const { workspace } = await createWorkspaceWithHook(
+			"TaskError.js",
+			`let data='';process.stdin.on('data',c=>data+=c);process.stdin.on('end',()=>{require('node:fs').writeFileSync(${JSON.stringify(outputPath)}, data);});\n`,
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			await hooks?.onStopError?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 3,
+				error: new Error("401 unauthorized"),
+			});
+			const payload = JSON.parse(await waitForFile(outputPath)) as {
+				hookName: string;
+				error?: { message?: string };
+			};
+			expect(payload.hookName).toBe("agent_error");
+			expect(payload.error?.message).toBe("401 unauthorized");
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
 });

package/src/runtime/hook-file-hooks.ts

@@ -30,6 +30,9 @@ type AgentHookToolCallEndContext = Parameters<
 type AgentHookTurnEndContext = Parameters<
 	NonNullable<AgentHooks["onTurnEnd"]>
 >[0];
+type AgentHookStopErrorContext = Parameters<
+	NonNullable<AgentHooks["onStopError"]>
+>[0];
 type AgentHookSessionShutdownContext = Parameters<
 	NonNullable<AgentHooks["onSessionShutdown"]>
 >[0];
@@ -201,6 +204,42 @@ function parseHookStdout(stdout: string): {
 	}
 }
 
+async function writeToChildStdin(
+	child: ReturnType<typeof spawn>,
+	body: string,
+): Promise<void> {
+	const stdin = child.stdin;
+	if (!stdin) {
+		throw new Error("hook command failed to create stdin");
+	}
+
+	await new Promise<void>((resolve, reject) => {
+		const onError = (error: Error) => {
+			stdin.off("error", onError);
+			const code = (error as Error & { code?: string }).code;
+			if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+				resolve();
+				return;
+			}
+			reject(error);
+		};
+		stdin.once("error", onError);
+		stdin.end(body, (error?: Error | null) => {
+			stdin.off("error", onError);
+			if (error) {
+				const code = (error as Error & { code?: string }).code;
+				if (code === "EPIPE" || code === "ERR_STREAM_DESTROYED") {
+					resolve();
+					return;
+				}
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+
 async function runHookCommand(
 	payload: HookEventPayload,
 	options: {
@@ -222,19 +261,18 @@ async function runHookCommand(
 			: ["pipe", "pipe", "pipe"],
 		detached: options.detached,
 	});
+	const spawned = new Promise<void>((resolve) => {
+		child.once("spawn", () => resolve());
+	});
+	const childError = new Promise<never>((_, reject) => {
+		child.once("error", (error) => reject(error));
+	});
 
 	const body = JSON.stringify(payload);
-	if (!child.stdin) {
-		throw new Error("hook command failed to create stdin");
-	}
-	child.stdin.write(body);
-	child.stdin.end();
+	await writeToChildStdin(child, body);
 
 	if (options.detached) {
-		await new Promise<void>((resolve, reject) => {
-			child.once("error", reject);
-			child.once("spawn", () => resolve());
-		});
+		await Promise.race([spawned, childError]);
 		child.unref();
 		return;
 	}
@@ -253,8 +291,7 @@ async function runHookCommand(
 		stderr += chunk.toString();
 	});
 
-	return await new Promise<HookCommandResult>((resolve, reject) => {
-		child.once("error", reject);
+	const result = new Promise<HookCommandResult>((resolve) => {
 		if ((options.timeoutMs ?? 0) > 0) {
 			timeoutId = setTimeout(() => {
 				timedOut = true;
@@ -276,6 +313,7 @@ async function runHookCommand(
 			});
 		});
 	});
+	return await Promise.race([result, childError]);
 }
 
 function parseShebangCommand(path: string): string[] | undefined {
@@ -323,6 +361,9 @@ function inferHookCommand(path: string): string[] {
 	) {
 		return ["bun", "run", path];
 	}
+	if (lowered.endsWith(".py")) {
+		return ["python3", path];
+	}
 	// Default to bash for legacy hook files with no extension/shebang.
 	return ["/bin/bash", path];
 }
@@ -488,6 +529,19 @@ export function createHookAuditHooks(options: {
 			});
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			append({
+				...createPayloadBase(ctx, runtimeOptions),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			});
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			if (isAbortReason(ctx.reason)) {
 				append({
@@ -631,6 +685,30 @@ export function createHookConfigFileHooks(
 		});
 	};
 
+	const runStopError = async (
+		ctx: AgentHookStopErrorContext,
+	): Promise<void> => {
+		const commandPaths = commandMap.agent_error ?? [];
+		if (commandPaths.length === 0) {
+			return;
+		}
+		runAsyncHookCommands({
+			commands: commandPaths,
+			cwd: options.cwd,
+			logger: options.logger,
+			payload: {
+				...createPayloadBase(ctx, options),
+				hookName: "agent_error",
+				iteration: ctx.iteration,
+				error: {
+					name: ctx.error.name,
+					message: ctx.error.message,
+					stack: ctx.error.stack,
+				},
+			},
+		});
+	};
+
 	const runSessionShutdown = async (
 		ctx: AgentHookSessionShutdownContext,
 	): Promise<void> => {
@@ -681,6 +759,10 @@ export function createHookConfigFileHooks(
 			await runTurnEnd(ctx);
 			return undefined;
 		},
+		onStopError: async (ctx: AgentHookStopErrorContext) => {
+			await runStopError(ctx);
+			return undefined;
+		},
 		onSessionShutdown: async (ctx: AgentHookSessionShutdownContext) => {
 			await runSessionShutdown(ctx);
 			return undefined;

package/src/runtime/runtime-builder.test.ts

@@ -3,6 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { Tool } from "@clinebot/agents";
 import { describe, expect, it } from "vitest";
+import { TelemetryService } from "../telemetry/TelemetryService";
 import { DefaultRuntimeBuilder } from "./runtime-builder";
 
 function makeSpawnTool(): Tool {
@@ -55,6 +56,25 @@ describe("DefaultRuntimeBuilder", () => {
 		expect(runtime.logger).toBe(logger);
 	});
 
+	it("forwards telemetry for downstream runtime consumers", () => {
+		const telemetry = new TelemetryService();
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				enableTools: false,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				telemetry,
+			},
+		});
+
+		expect(runtime.telemetry).toBe(telemetry);
+	});
+
 	it("uses readonly preset in plan mode", () => {
 		const runtime = new DefaultRuntimeBuilder().build({
 			config: {

package/src/runtime/runtime-builder.ts

@@ -522,6 +522,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		return {
 			tools,
 			logger: logger ?? config.logger,
+			telemetry: input.telemetry ?? config.telemetry,
 			teamRuntime,
 			completionGuard,
 			shutdown: (reason: string) => {

package/src/runtime/session-runtime.ts

@@ -5,7 +5,7 @@ import type {
 	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 "../tools";
 import type { CoreSessionConfig } from "../types/config";
@@ -14,6 +14,7 @@ export interface BuiltRuntime {
 	tools: Tool[];
 	hooks?: AgentHooks;
 	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
 	teamRuntime?: AgentTeamsRuntime;
 	completionGuard?: () => string | undefined;
 	shutdown: (reason: string) => Promise<void> | void;
@@ -29,6 +30,7 @@ export interface RuntimeBuilderInput {
 	userInstructionWatcher?: UserInstructionConfigWatcher;
 	defaultToolExecutors?: Partial<ToolExecutors>;
 	logger?: BasicLogger;
+	telemetry?: ITelemetryService;
 }
 
 export interface RuntimeBuilder {