@clinebot/core 0.0.21 → 0.0.23

package/src/mcp/manager.ts

@@ -0,0 +1,262 @@
+import type {
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+} from "@clinebot/agents";
+import type {
+	McpConnectionStatus,
+	McpManager,
+	McpManagerOptions,
+	McpServerClient,
+	McpServerRegistration,
+	McpServerSnapshot,
+} from "./types";
+
+const DEFAULT_TOOLS_CACHE_TTL_MS = 5000;
+
+type ManagedServerState = {
+	registration: McpServerRegistration;
+	client?: McpServerClient;
+	status: McpConnectionStatus;
+	lastError?: string;
+	updatedAt: number;
+	toolCache?: readonly McpToolDescriptor[];
+	toolCacheUpdatedAt?: number;
+};
+
+function nowMs(): number {
+	return Date.now();
+}
+
+function cloneTools(
+	tools: readonly McpToolDescriptor[],
+): readonly McpToolDescriptor[] {
+	return tools.map((tool) => ({
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputSchema,
+	}));
+}
+
+export class InMemoryMcpManager implements McpManager {
+	private readonly toolsCacheTtlMs: number;
+	private readonly clientFactory: McpManagerOptions["clientFactory"];
+	private readonly servers = new Map<string, ManagedServerState>();
+	private readonly operationLocks = new Map<string, Promise<void>>();
+
+	constructor(options: McpManagerOptions) {
+		this.clientFactory = options.clientFactory;
+		this.toolsCacheTtlMs =
+			options.toolsCacheTtlMs ?? DEFAULT_TOOLS_CACHE_TTL_MS;
+	}
+
+	async registerServer(registration: McpServerRegistration): Promise<void> {
+		await this.runExclusive(registration.name, async () => {
+			const existing = this.servers.get(registration.name);
+			if (!existing) {
+				this.servers.set(registration.name, {
+					registration: { ...registration },
+					status: "disconnected",
+					updatedAt: nowMs(),
+				});
+				return;
+			}
+
+			const didTransportChange =
+				JSON.stringify(existing.registration.transport) !==
+				JSON.stringify(registration.transport);
+			existing.registration = { ...registration };
+			existing.updatedAt = nowMs();
+
+			if (didTransportChange) {
+				await this.disconnectState(existing);
+				existing.client = undefined;
+				existing.toolCache = undefined;
+				existing.toolCacheUpdatedAt = undefined;
+			}
+		});
+	}
+
+	async unregisterServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.disconnectState(state);
+			this.servers.delete(serverName);
+		});
+	}
+
+	async connectServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.connectState(state);
+		});
+	}
+
+	async disconnectServer(serverName: string): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			await this.disconnectState(state);
+		});
+	}
+
+	async setServerDisabled(
+		serverName: string,
+		disabled: boolean,
+	): Promise<void> {
+		await this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			state.registration = {
+				...state.registration,
+				disabled,
+			};
+			state.updatedAt = nowMs();
+			if (disabled) {
+				await this.disconnectState(state);
+			}
+		});
+	}
+
+	listServers(): readonly McpServerSnapshot[] {
+		return [...this.servers.values()]
+			.map((state) => ({
+				name: state.registration.name,
+				status: state.status,
+				disabled: state.registration.disabled === true,
+				lastError: state.lastError,
+				toolCount: state.toolCache?.length ?? 0,
+				updatedAt: state.updatedAt,
+				metadata: state.registration.metadata,
+			}))
+			.sort((a, b) => a.name.localeCompare(b.name));
+	}
+
+	async listTools(serverName: string): Promise<readonly McpToolDescriptor[]> {
+		const state = this.requireServer(serverName);
+		const fetchedAt = state.toolCacheUpdatedAt ?? 0;
+		if (state.toolCache && nowMs() - fetchedAt <= this.toolsCacheTtlMs) {
+			return state.toolCache;
+		}
+		return this.refreshTools(serverName);
+	}
+
+	async refreshTools(
+		serverName: string,
+	): Promise<readonly McpToolDescriptor[]> {
+		return this.runExclusive(serverName, async () => {
+			const state = this.requireServer(serverName);
+			const client = await this.ensureConnectedClient(state);
+			const tools = await client.listTools();
+			const cloned = cloneTools(tools);
+			state.toolCache = cloned;
+			state.toolCacheUpdatedAt = nowMs();
+			state.updatedAt = nowMs();
+			return cloned;
+		});
+	}
+
+	async callTool(request: McpToolCallRequest): Promise<McpToolCallResult> {
+		return this.runExclusive(request.serverName, async () => {
+			const state = this.requireServer(request.serverName);
+			const client = await this.ensureConnectedClient(state);
+			state.updatedAt = nowMs();
+			return client.callTool({
+				name: request.toolName,
+				arguments: request.arguments,
+				context: request.context,
+			});
+		});
+	}
+
+	async dispose(): Promise<void> {
+		const names = [...this.servers.keys()];
+		for (const name of names) {
+			await this.unregisterServer(name);
+		}
+	}
+
+	private async ensureConnectedClient(
+		state: ManagedServerState,
+	): Promise<McpServerClient> {
+		await this.connectState(state);
+		if (!state.client) {
+			throw new Error(
+				`MCP server "${state.registration.name}" does not have an initialized client.`,
+			);
+		}
+		return state.client;
+	}
+
+	private async connectState(state: ManagedServerState): Promise<void> {
+		if (state.registration.disabled) {
+			throw new Error(
+				`MCP server "${state.registration.name}" is disabled and cannot be connected.`,
+			);
+		}
+		if (state.status === "connected" && state.client) {
+			return;
+		}
+		state.status = "connecting";
+		state.updatedAt = nowMs();
+		try {
+			const client =
+				state.client ?? (await this.clientFactory(state.registration));
+			await client.connect();
+			state.client = client;
+			state.status = "connected";
+			state.lastError = undefined;
+			state.updatedAt = nowMs();
+		} catch (error) {
+			state.status = "disconnected";
+			state.lastError = error instanceof Error ? error.message : String(error);
+			state.updatedAt = nowMs();
+			throw error;
+		}
+	}
+
+	private async disconnectState(state: ManagedServerState): Promise<void> {
+		if (!state.client) {
+			state.status = "disconnected";
+			state.updatedAt = nowMs();
+			return;
+		}
+
+		try {
+			await state.client.disconnect();
+		} finally {
+			state.status = "disconnected";
+			state.updatedAt = nowMs();
+		}
+	}
+
+	private requireServer(serverName: string): ManagedServerState {
+		const state = this.servers.get(serverName);
+		if (!state) {
+			throw new Error(`Unknown MCP server: ${serverName}`);
+		}
+		return state;
+	}
+
+	private async runExclusive<T>(
+		serverName: string,
+		operation: () => Promise<T>,
+	): Promise<T> {
+		const previous = this.operationLocks.get(serverName) ?? Promise.resolve();
+		let releaseCurrent: (() => void) | undefined;
+		const current = new Promise<void>((resolve) => {
+			releaseCurrent = resolve;
+		});
+		const queued = previous.catch(() => undefined).then(() => current);
+		this.operationLocks.set(serverName, queued);
+
+		await previous.catch(() => undefined);
+		try {
+			return await operation();
+		} finally {
+			releaseCurrent?.();
+			const lock = this.operationLocks.get(serverName);
+			if (lock === queued) {
+				this.operationLocks.delete(serverName);
+			}
+		}
+	}
+}

package/src/mcp/types.ts

@@ -0,0 +1,88 @@
+import type {
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+	McpToolProvider,
+	ToolContext,
+} from "@clinebot/agents";
+
+export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
+
+export interface McpStdioTransportConfig {
+	type: "stdio";
+	command: string;
+	args?: string[];
+	cwd?: string;
+	env?: Record<string, string>;
+}
+
+export interface McpSseTransportConfig {
+	type: "sse";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export interface McpStreamableHttpTransportConfig {
+	type: "streamableHttp";
+	url: string;
+	headers?: Record<string, string>;
+}
+
+export type McpServerTransportConfig =
+	| McpStdioTransportConfig
+	| McpSseTransportConfig
+	| McpStreamableHttpTransportConfig;
+
+export interface McpServerRegistration {
+	name: string;
+	transport: McpServerTransportConfig;
+	disabled?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export interface McpServerSnapshot {
+	name: string;
+	status: McpConnectionStatus;
+	disabled: boolean;
+	lastError?: string;
+	toolCount: number;
+	updatedAt: number;
+	metadata?: Record<string, unknown>;
+}
+
+export interface McpServerClient {
+	connect(): Promise<void>;
+	disconnect(): Promise<void>;
+	listTools(): Promise<readonly McpToolDescriptor[]>;
+	callTool(request: {
+		name: string;
+		arguments?: Record<string, unknown>;
+		context?: ToolContext;
+	}): Promise<McpToolCallResult>;
+}
+
+export type McpServerClientFactory = (
+	registration: McpServerRegistration,
+) => Promise<McpServerClient> | McpServerClient;
+
+export interface McpManagerOptions {
+	clientFactory: McpServerClientFactory;
+	/**
+	 * Cache TTL for tools/list responses.
+	 * A short cache avoids repeated list requests while keeping server metadata fresh.
+	 * @default 5000
+	 */
+	toolsCacheTtlMs?: number;
+}
+
+export interface McpManager extends McpToolProvider {
+	registerServer(registration: McpServerRegistration): Promise<void>;
+	unregisterServer(serverName: string): Promise<void>;
+	connectServer(serverName: string): Promise<void>;
+	disconnectServer(serverName: string): Promise<void>;
+	setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+	listServers(): readonly McpServerSnapshot[];
+	refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+	callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+	dispose(): Promise<void>;
+}

package/src/providers/local-provider-registry.ts

@@ -0,0 +1,232 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import * as LlmsModels from "@clinebot/llms/models";
+import type { RpcProviderCapability, RpcProviderModel } from "@clinebot/shared";
+import type { ProviderSettingsManager } from "../storage/provider-settings-manager";
+
+export type StoredModelsFile = {
+	version: 1;
+	providers: Record<
+		string,
+		{
+			provider: {
+				name: string;
+				baseUrl: string;
+				defaultModelId?: string;
+				capabilities?: RpcProviderCapability[];
+				modelsSourceUrl?: string;
+			};
+			models: Record<
+				string,
+				{
+					id: string;
+					name: string;
+					supportsVision?: boolean;
+					supportsAttachments?: boolean;
+					supportsReasoning?: boolean;
+				}
+			>;
+		}
+	>;
+};
+
+const LOADED_MODELS_REGISTRY_PATHS = new Set<string>();
+
+function titleCaseFromId(id: string): string {
+	return id
+		.split(/[-_]/)
+		.filter(Boolean)
+		.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+		.join(" ");
+}
+
+export function resolveModelsRegistryPath(
+	manager: ProviderSettingsManager,
+): string {
+	return join(dirname(manager.getFilePath()), "models.json");
+}
+
+export function emptyModelsFile(): StoredModelsFile {
+	return { version: 1, providers: {} };
+}
+
+export function readModelsFileSync(filePath: string): StoredModelsFile {
+	if (!existsSync(filePath)) {
+		return emptyModelsFile();
+	}
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		const parsed = JSON.parse(raw) as Partial<StoredModelsFile>;
+		if (
+			parsed &&
+			parsed.version === 1 &&
+			parsed.providers &&
+			typeof parsed.providers === "object"
+		) {
+			return { version: 1, providers: parsed.providers };
+		}
+	} catch {
+		// Invalid or missing files fall back to an empty registry.
+	}
+	return emptyModelsFile();
+}
+
+export async function readModelsFile(
+	filePath: string,
+): Promise<StoredModelsFile> {
+	try {
+		const raw = await readFile(filePath, "utf8");
+		const parsed = JSON.parse(raw) as Partial<StoredModelsFile>;
+		if (
+			parsed &&
+			parsed.version === 1 &&
+			parsed.providers &&
+			typeof parsed.providers === "object"
+		) {
+			return { version: 1, providers: parsed.providers };
+		}
+	} catch {
+		// Invalid or missing files fall back to an empty registry.
+	}
+	return emptyModelsFile();
+}
+
+export function writeModelsFileSync(
+	filePath: string,
+	state: StoredModelsFile,
+): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+export async function writeModelsFile(
+	filePath: string,
+	state: StoredModelsFile,
+): Promise<void> {
+	await mkdir(dirname(filePath), { recursive: true });
+	await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+export function toRpcProviderModel(
+	modelId: string,
+	info: {
+		name?: string;
+		capabilities?: string[];
+		thinkingConfig?: unknown;
+	},
+): RpcProviderModel {
+	return {
+		id: modelId,
+		name: info.name ?? modelId,
+		supportsAttachments: info.capabilities?.includes("files"),
+		supportsVision: info.capabilities?.includes("images"),
+		supportsReasoning:
+			info.capabilities?.includes("reasoning") || info.thinkingConfig != null,
+	};
+}
+
+function toProviderCapabilities(
+	capabilities: RpcProviderCapability[] | undefined,
+): Array<"reasoning" | "prompt-cache" | "tools"> | undefined {
+	if (!capabilities || capabilities.length === 0) {
+		return undefined;
+	}
+	const next = new Set<"reasoning" | "prompt-cache" | "tools">();
+	if (capabilities.includes("reasoning")) {
+		next.add("reasoning");
+	}
+	if (capabilities.includes("prompt-cache")) {
+		next.add("prompt-cache");
+	}
+	if (capabilities.includes("tools")) {
+		next.add("tools");
+	}
+	return next.size > 0 ? [...next] : undefined;
+}
+
+function toModelCapabilities(
+	capabilities: RpcProviderCapability[] | undefined,
+): Array<
+	"streaming" | "tools" | "reasoning" | "prompt-cache" | "images" | "files"
+> {
+	const next = new Set<
+		"streaming" | "tools" | "reasoning" | "prompt-cache" | "images" | "files"
+	>();
+	if (!capabilities || capabilities.length === 0) {
+		return [...next];
+	}
+	if (capabilities.includes("streaming")) next.add("streaming");
+	if (capabilities.includes("tools")) next.add("tools");
+	if (capabilities.includes("reasoning")) next.add("reasoning");
+	if (capabilities.includes("prompt-cache")) next.add("prompt-cache");
+	if (capabilities.includes("vision")) {
+		next.add("images");
+		next.add("files");
+	}
+	return [...next];
+}
+
+export function registerCustomProvider(
+	providerId: string,
+	entry: StoredModelsFile["providers"][string],
+): void {
+	const modelCapabilities = toModelCapabilities(entry.provider.capabilities);
+	const modelEntries = Object.values(entry.models)
+		.map((model) => model.id.trim())
+		.filter((modelId) => modelId.length > 0);
+	const defaultModelId =
+		entry.provider.defaultModelId?.trim() || modelEntries[0] || "default";
+	const normalizedModels = Object.fromEntries(
+		modelEntries.map((modelId) => [
+			modelId,
+			{
+				id: modelId,
+				name: entry.models[modelId]?.name ?? modelId,
+				capabilities:
+					modelCapabilities.length > 0 ? modelCapabilities : undefined,
+				status: "active" as const,
+			},
+		]),
+	);
+
+	LlmsModels.registerProvider({
+		provider: {
+			id: providerId,
+			name: entry.provider.name.trim() || titleCaseFromId(providerId),
+			protocol: "openai-chat",
+			baseUrl: entry.provider.baseUrl,
+			defaultModelId,
+			capabilities: toProviderCapabilities(entry.provider.capabilities),
+		},
+		models: normalizedModels,
+	});
+}
+
+export function ensureCustomProvidersLoadedSync(
+	manager: ProviderSettingsManager,
+): void {
+	const modelsPath = resolveModelsRegistryPath(manager);
+	if (LOADED_MODELS_REGISTRY_PATHS.has(modelsPath)) {
+		return;
+	}
+	const state = readModelsFileSync(modelsPath);
+	for (const [providerId, entry] of Object.entries(state.providers)) {
+		registerCustomProvider(providerId, entry);
+	}
+	LOADED_MODELS_REGISTRY_PATHS.add(modelsPath);
+}
+
+export async function ensureCustomProvidersLoaded(
+	manager: ProviderSettingsManager,
+): Promise<void> {
+	const modelsPath = resolveModelsRegistryPath(manager);
+	if (LOADED_MODELS_REGISTRY_PATHS.has(modelsPath)) {
+		return;
+	}
+	const state = await readModelsFile(modelsPath);
+	for (const [providerId, entry] of Object.entries(state.providers)) {
+		registerCustomProvider(providerId, entry);
+	}
+	LOADED_MODELS_REGISTRY_PATHS.add(modelsPath);
+}