@hotmeshio/long-tail 0.1.0

package/build/services/maintenance/index.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maintenanceRegistry = void 0;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const pg_1 = require("pg");
+const config_1 = require("../../modules/config");
+const logger_1 = require("../logger");
+const dbaService = __importStar(require("../dba"));
+const CRON_TOPIC = 'lt.maintenance.prune';
+const CRON_ID = 'lt-maintenance-nightly';
+/**
+ * Translate a single maintenance rule into the appropriate dbaService.prune() call.
+ */
+async function executeRule(rule) {
+    switch (true) {
+        // Delete stream messages
+        case rule.target === 'streams' && rule.action === 'delete':
+            await dbaService.prune({
+                expire: rule.olderThan,
+                streams: true,
+                jobs: false,
+            });
+            break;
+        // Delete transient jobs (entity IS NULL)
+        case rule.target === 'jobs' && rule.action === 'delete' && rule.hasEntity === false:
+            await dbaService.prune({
+                expire: rule.olderThan,
+                jobs: false,
+                streams: false,
+                pruneTransient: true,
+            });
+            break;
+        // Strip execution artifacts from entity jobs (keep jdata/udata/jmark/hmark)
+        case rule.target === 'jobs' && rule.action === 'prune' && rule.hasEntity === true:
+            await dbaService.prune({
+                expire: rule.olderThan,
+                jobs: false,
+                streams: false,
+                attributes: true,
+                keepHmark: true,
+            });
+            break;
+        // Hard-delete old pruned jobs
+        case rule.target === 'jobs' && rule.action === 'delete' && rule.pruned === true:
+            await dbaService.prune({
+                expire: rule.olderThan,
+                jobs: true,
+                streams: false,
+            });
+            break;
+        default:
+            logger_1.loggerRegistry.warn(`[lt-maintenance] unknown rule, skipping: ${JSON.stringify(rule)}`);
+    }
+}
+/**
+ * Singleton registry for automatic database maintenance.
+ *
+ * Follows the same pattern as telemetryRegistry and eventRegistry:
+ * - register(config) — set the maintenance schedule and rules
+ * - connect()        — start the Virtual.cron
+ * - disconnect()     — interrupt the cron
+ * - clear()          — reset (for tests)
+ */
+class LTMaintenanceRegistry {
+    constructor() {
+        this._config = null;
+        this.connected = false;
+    }
+    /**
+     * Register a maintenance configuration. Call before connect().
+     * Replaces any previously registered config.
+     */
+    register(config) {
+        this._config = config;
+    }
+    /**
+     * Start the maintenance cron using Virtual.cron().
+     * Idempotent — given the same CRON_ID, restarts won't duplicate.
+     */
+    async connect() {
+        if (this.connected || !this._config)
+            return;
+        const rules = this._config.rules;
+        const schedule = this._config.schedule;
+        const connection = { class: pg_1.Client, options: config_1.postgres_options };
+        await hotmesh_1.Virtual.cron({
+            topic: CRON_TOPIC,
+            connection,
+            callback: async () => {
+                logger_1.loggerRegistry.info('[lt-maintenance] starting maintenance cycle...');
+                for (const rule of rules) {
+                    try {
+                        await executeRule(rule);
+                    }
+                    catch (err) {
+                        logger_1.loggerRegistry.error(`[lt-maintenance] rule failed: ${JSON.stringify(rule)} ${err?.message}`);
+                    }
+                }
+                logger_1.loggerRegistry.info('[lt-maintenance] maintenance cycle complete.');
+            },
+            args: [],
+            options: {
+                id: CRON_ID,
+                interval: schedule,
+            },
+        });
+        this.connected = true;
+        logger_1.loggerRegistry.info(`[lt-maintenance] cron started (schedule: ${schedule})`);
+    }
+    /**
+     * Interrupt the running cron. Call during graceful shutdown.
+     */
+    async disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            const connection = { class: pg_1.Client, options: config_1.postgres_options };
+            await hotmesh_1.Virtual.interrupt({
+                topic: CRON_TOPIC,
+                connection,
+                options: { id: CRON_ID },
+            });
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[lt-maintenance] interrupt failed (may not be running): ${err?.message}`);
+        }
+        this.connected = false;
+    }
+    /**
+     * Remove config and reset state. Used in tests.
+     */
+    clear() {
+        this._config = null;
+        this.connected = false;
+    }
+    /**
+     * Check if a config is registered.
+     */
+    get hasConfig() {
+        return this._config !== null;
+    }
+    /**
+     * Get the current config.
+     */
+    get config() {
+        return this._config;
+    }
+}
+/** Singleton maintenance registry */
+exports.maintenanceRegistry = new LTMaintenanceRegistry();

package/build/services/mcp/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { LTMcpAdapter, LTMcpToolManifest } from '../../types/mcp';
+import type { BuiltInMcpAdapterOptions } from './types';
+/**
+ * Built-in MCP adapter.
+ *
+ * Manages:
+ * - One MCP server (human queue) that exposes escalation tools
+ * - Multiple MCP client connections to external servers
+ */
+export declare class BuiltInMcpAdapter implements LTMcpAdapter {
+    private readonly options;
+    constructor(options?: BuiltInMcpAdapterOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    connectClient(serverId: string): Promise<void>;
+    disconnectClient(serverId: string): Promise<void>;
+    listTools(serverId: string): Promise<LTMcpToolManifest[]>;
+    callTool(serverId: string, toolName: string, args: Record<string, any>, authContext?: {
+        userId?: string;
+        delegationToken?: string;
+    }): Promise<any>;
+    toolActivities(serverId: string): Promise<Record<string, (...args: any[]) => Promise<any>>>;
+}

package/build/services/mcp/adapter.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInMcpAdapter = void 0;
+const logger_1 = require("../logger");
+const mcpClient = __importStar(require("./client"));
+const mcpServer = __importStar(require("./server"));
+const mcpDbServer = __importStar(require("./db-server"));
+const mcpWorkflowCompilerServer = __importStar(require("./workflow-compiler-server"));
+const mcpWorkflowServer = __importStar(require("./workflow-server"));
+const mcpDbService = __importStar(require("./db"));
+/**
+ * Built-in MCP adapter.
+ *
+ * Manages:
+ * - One MCP server (human queue) that exposes escalation tools
+ * - Multiple MCP client connections to external servers
+ */
+class BuiltInMcpAdapter {
+    constructor(options) {
+        this.options = options || {};
+    }
+    async connect() {
+        // Start MCP server (human queue)
+        if (this.options.server?.enabled !== false) {
+            await mcpServer.createHumanQueueServer({
+                name: this.options.server?.name,
+            });
+            logger_1.loggerRegistry.info('[lt-mcp] human queue server started');
+        }
+        // Start DB query MCP server (always available)
+        await mcpDbServer.createDbServer();
+        logger_1.loggerRegistry.info('[lt-mcp] db query server started');
+        // Start Workflow Compiler MCP server (always available)
+        await mcpWorkflowCompilerServer.createWorkflowCompilerServer();
+        logger_1.loggerRegistry.info('[lt-mcp] workflow compiler server started');
+        // Start MCP Workflows server (exposes compiled YAML workflows as tools)
+        await mcpWorkflowServer.createWorkflowServer();
+        logger_1.loggerRegistry.info('[lt-mcp] workflow server started');
+        // Connect to auto-connect servers from DB
+        await mcpClient.connectAutoServers();
+        // Also connect to explicitly specified servers
+        if (this.options.autoConnect?.length) {
+            for (const serverId of this.options.autoConnect) {
+                try {
+                    const server = await mcpDbService.getMcpServer(serverId);
+                    if (server) {
+                        await mcpClient.connectToServer(server);
+                    }
+                    else {
+                        logger_1.loggerRegistry.warn(`[lt-mcp] auto-connect server not found: ${serverId}`);
+                    }
+                }
+                catch (err) {
+                    logger_1.loggerRegistry.error(`[lt-mcp] auto-connect failed for ${serverId}: ${err.message}`);
+                }
+            }
+        }
+    }
+    async disconnect() {
+        await mcpClient.disconnectAll();
+        await mcpWorkflowServer.stopWorkflowServer();
+        await mcpWorkflowCompilerServer.stopWorkflowCompilerServer();
+        await mcpDbServer.stopDbServer();
+        await mcpServer.stopServer();
+        logger_1.loggerRegistry.info('[lt-mcp] disconnected');
+    }
+    async connectClient(serverId) {
+        const server = await mcpDbService.getMcpServer(serverId);
+        if (!server)
+            throw new Error(`MCP server ${serverId} not found`);
+        await mcpClient.connectToServer(server);
+    }
+    async disconnectClient(serverId) {
+        await mcpClient.disconnectFromServer(serverId);
+    }
+    async listTools(serverId) {
+        return mcpClient.listServerTools(serverId);
+    }
+    async callTool(serverId, toolName, args, authContext) {
+        return mcpClient.callServerTool(serverId, toolName, args, authContext);
+    }
+    async toolActivities(serverId) {
+        return mcpClient.toolActivities(serverId);
+    }
+}
+exports.BuiltInMcpAdapter = BuiltInMcpAdapter;

package/build/services/mcp/client/connection.d.ts

@@ -0,0 +1,46 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { LTMcpServerRecord, LTMcpToolManifest } from '../../../types';
+/**
+ * Register a built-in server factory so it can be auto-connected
+ * when callServerTool is invoked with its name.
+ */
+export declare function registerBuiltinServer(name: string, factory: () => Promise<any>): void;
+/**
+ * Connect to a registered MCP server.
+ * Creates the appropriate transport based on transport_type,
+ * connects, and caches tool manifest in DB.
+ */
+export declare function connectToServer(server: LTMcpServerRecord): Promise<Client>;
+/**
+ * Disconnect from a specific server.
+ */
+export declare function disconnectFromServer(serverId: string): Promise<void>;
+/**
+ * Resolve a server by ID or name, auto-connecting built-in servers if needed.
+ * Returns the client or null if not found.
+ *
+ * Built-in servers are connected once under their canonical factory name.
+ * Alias lookups (e.g. 'vision' matching 'long-tail-document-vision') reuse
+ * the same client instance to avoid double-connecting the singleton server.
+ */
+export declare function resolveClient(serverId: string): Promise<Client | null>;
+/**
+ * Connect to all auto-connect servers.
+ */
+export declare function connectAutoServers(): Promise<void>;
+/**
+ * Disconnect all clients.
+ */
+export declare function disconnectAll(): Promise<void>;
+/**
+ * List tools from a connected server.
+ */
+export declare function listServerTools(serverId: string): Promise<LTMcpToolManifest[]>;
+/**
+ * Check if a server is connected.
+ */
+export declare function isConnected(serverId: string): boolean;
+/**
+ * Clear all state. Used in tests.
+ */
+export declare function clear(): void;

package/build/services/mcp/client/connection.js

@@ -0,0 +1,280 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBuiltinServer = registerBuiltinServer;
+exports.connectToServer = connectToServer;
+exports.disconnectFromServer = disconnectFromServer;
+exports.resolveClient = resolveClient;
+exports.connectAutoServers = connectAutoServers;
+exports.disconnectAll = disconnectAll;
+exports.listServerTools = listServerTools;
+exports.isConnected = isConnected;
+exports.clear = clear;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
+const logger_1 = require("../../logger");
+const mcpDbService = __importStar(require("../db"));
+/** In-memory map of server ID/name to active MCP client */
+const clients = new Map();
+/**
+ * Built-in server factories -- keyed by server name.
+ * These are in-process MCP servers that connect via InMemoryTransport
+ * rather than external stdio/SSE connections.
+ */
+const builtinFactories = new Map();
+/**
+ * Register a built-in server factory so it can be auto-connected
+ * when callServerTool is invoked with its name.
+ */
+function registerBuiltinServer(name, factory) {
+    builtinFactories.set(name, factory);
+}
+/**
+ * Connect to a registered MCP server.
+ * Creates the appropriate transport based on transport_type,
+ * connects, and caches tool manifest in DB.
+ */
+async function connectToServer(server) {
+    if (clients.has(server.id)) {
+        return clients.get(server.id);
+    }
+    // Built-in servers use InMemoryTransport via their registered factory
+    if (server.transport_config?.builtin) {
+        // Find matching factory by server name
+        for (const [name, factory] of builtinFactories) {
+            if (server.name === name || name.includes(server.name) || server.name.includes(name)) {
+                // Reuse existing client if factory was already connected
+                if (clients.has(name)) {
+                    clients.set(server.id, clients.get(name));
+                    await mcpDbService.updateMcpServerStatus(server.id, 'connected');
+                    return clients.get(name);
+                }
+                const srv = await factory();
+                const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+                await srv.connect(serverTransport);
+                const client = new index_js_1.Client({ name: `builtin-${name}`, version: '1.0.0' });
+                await client.connect(clientTransport);
+                clients.set(name, client);
+                clients.set(server.id, client);
+                // Cache the tool manifest
+                const { tools } = await client.listTools();
+                const manifest = tools.map((t) => ({
+                    name: t.name,
+                    description: t.description || '',
+                    inputSchema: t.inputSchema || {},
+                }));
+                await mcpDbService.updateMcpServerStatus(server.id, 'connected', manifest);
+                logger_1.loggerRegistry.info(`[lt-mcp:client] connected builtin server: ${name} (${manifest.length} tools)`);
+                return client;
+            }
+        }
+        throw new Error(`No builtin factory registered for server: ${server.name}`);
+    }
+    const client = new index_js_1.Client({ name: 'long-tail', version: '1.0.0' });
+    let transport;
+    if (server.transport_type === 'stdio') {
+        transport = new stdio_js_1.StdioClientTransport({
+            command: server.transport_config.command,
+            args: server.transport_config.args || [],
+            env: server.transport_config.env,
+        });
+    }
+    else {
+        transport = new sse_js_1.SSEClientTransport(new URL(server.transport_config.url));
+    }
+    await client.connect(transport);
+    clients.set(server.id, client);
+    // Cache the tool manifest
+    const { tools } = await client.listTools();
+    const manifest = tools.map((t) => ({
+        name: t.name,
+        description: t.description || '',
+        inputSchema: t.inputSchema || {},
+    }));
+    await mcpDbService.updateMcpServerStatus(server.id, 'connected', manifest);
+    logger_1.loggerRegistry.info(`[lt-mcp:client] connected to ${server.name} (${manifest.length} tools)`);
+    return client;
+}
+/**
+ * Disconnect from a specific server.
+ */
+async function disconnectFromServer(serverId) {
+    const client = clients.get(serverId);
+    if (client) {
+        await client.close();
+        clients.delete(serverId);
+        await mcpDbService.updateMcpServerStatus(serverId, 'disconnected');
+        logger_1.loggerRegistry.info(`[lt-mcp:client] disconnected from ${serverId}`);
+    }
+}
+/**
+ * Resolve a server by ID or name, auto-connecting built-in servers if needed.
+ * Returns the client or null if not found.
+ *
+ * Built-in servers are connected once under their canonical factory name.
+ * Alias lookups (e.g. 'vision' matching 'long-tail-document-vision') reuse
+ * the same client instance to avoid double-connecting the singleton server.
+ */
+async function resolveClient(serverId) {
+    // 1. Direct lookup (by UUID or name)
+    if (clients.has(serverId))
+        return clients.get(serverId);
+    // 2. Check built-in server factories -- exact match first, then fuzzy
+    let matchedName = null;
+    if (builtinFactories.has(serverId)) {
+        matchedName = serverId;
+    }
+    else {
+        for (const [name] of builtinFactories) {
+            if (name.includes(serverId) || serverId.includes(name)) {
+                matchedName = name;
+                break;
+            }
+        }
+    }
+    if (matchedName) {
+        const factory = builtinFactories.get(matchedName);
+        // Check if we already connected this factory under its canonical name
+        if (clients.has(matchedName)) {
+            // Alias the serverId to the existing client so future lookups are instant
+            clients.set(serverId, clients.get(matchedName));
+            return clients.get(matchedName);
+        }
+        const server = await factory();
+        const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+        await server.connect(serverTransport);
+        const client = new index_js_1.Client({ name: `builtin-${matchedName}`, version: '1.0.0' });
+        await client.connect(clientTransport);
+        // Cache under both the canonical name and the requested serverId
+        clients.set(matchedName, client);
+        if (serverId !== matchedName)
+            clients.set(serverId, client);
+        logger_1.loggerRegistry.info(`[lt-mcp:client] auto-connected built-in server: ${matchedName} (as '${serverId}')`);
+        return client;
+    }
+    // 3. Look up in DB by ID or name, then try to match a built-in factory
+    try {
+        const dbServer = (await mcpDbService.getMcpServer(serverId)) ||
+            (await mcpDbService.getMcpServerByName(serverId));
+        if (dbServer) {
+            // Already connected under its DB id?
+            if (clients.has(dbServer.id)) {
+                clients.set(serverId, clients.get(dbServer.id));
+                return clients.get(dbServer.id);
+            }
+            // Match DB server name to a built-in factory
+            for (const [name, factory] of builtinFactories) {
+                if (dbServer.name === name || name.includes(dbServer.name) || dbServer.name.includes(name)) {
+                    if (clients.has(name)) {
+                        clients.set(serverId, clients.get(name));
+                        return clients.get(name);
+                    }
+                    const srv = await factory();
+                    const [clientTransport, serverTransport] = inMemory_js_1.InMemoryTransport.createLinkedPair();
+                    await srv.connect(serverTransport);
+                    const client = new index_js_1.Client({ name: `builtin-${name}`, version: '1.0.0' });
+                    await client.connect(clientTransport);
+                    clients.set(name, client);
+                    clients.set(dbServer.id, client);
+                    if (serverId !== name && serverId !== dbServer.id)
+                        clients.set(serverId, client);
+                    logger_1.loggerRegistry.info(`[lt-mcp:client] auto-connected built-in server: ${name} (via DB id '${serverId}')`);
+                    return client;
+                }
+            }
+        }
+    }
+    catch {
+        // DB lookup failed -- not critical
+    }
+    return null;
+}
+/**
+ * Connect to all auto-connect servers.
+ */
+async function connectAutoServers() {
+    const servers = await mcpDbService.getAutoConnectServers();
+    for (const server of servers) {
+        // Skip built-in servers -- they auto-connect lazily via resolveClient()
+        // on first tool call using InMemoryTransport, not stdio/SSE.
+        if (server.transport_config?.builtin) {
+            continue;
+        }
+        try {
+            await connectToServer(server);
+        }
+        catch (err) {
+            logger_1.loggerRegistry.error(`[lt-mcp:client] failed to connect to ${server.name}: ${err.message}`);
+            await mcpDbService.updateMcpServerStatus(server.id, 'error');
+        }
+    }
+}
+/**
+ * Disconnect all clients.
+ */
+async function disconnectAll() {
+    for (const [serverId] of clients) {
+        await disconnectFromServer(serverId);
+    }
+}
+/**
+ * List tools from a connected server.
+ */
+async function listServerTools(serverId) {
+    const client = clients.get(serverId);
+    if (!client) {
+        throw new Error(`MCP server ${serverId} is not connected`);
+    }
+    const { tools } = await client.listTools();
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description || '',
+        inputSchema: t.inputSchema || {},
+    }));
+}
+/**
+ * Check if a server is connected.
+ */
+function isConnected(serverId) {
+    return clients.has(serverId);
+}
+/**
+ * Clear all state. Used in tests.
+ */
+function clear() {
+    clients.clear();
+}

package/build/services/mcp/client/index.d.ts

@@ -0,0 +1,2 @@
+export { registerBuiltinServer, connectToServer, disconnectFromServer, listServerTools, resolveClient, connectAutoServers, disconnectAll, isConnected, clear, } from './connection';
+export { callServerTool, toolActivities, } from './tools';

package/build/services/mcp/client/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolActivities = exports.callServerTool = exports.clear = exports.isConnected = exports.disconnectAll = exports.connectAutoServers = exports.resolveClient = exports.listServerTools = exports.disconnectFromServer = exports.connectToServer = exports.registerBuiltinServer = void 0;
+var connection_1 = require("./connection");
+Object.defineProperty(exports, "registerBuiltinServer", { enumerable: true, get: function () { return connection_1.registerBuiltinServer; } });
+Object.defineProperty(exports, "connectToServer", { enumerable: true, get: function () { return connection_1.connectToServer; } });
+Object.defineProperty(exports, "disconnectFromServer", { enumerable: true, get: function () { return connection_1.disconnectFromServer; } });
+Object.defineProperty(exports, "listServerTools", { enumerable: true, get: function () { return connection_1.listServerTools; } });
+Object.defineProperty(exports, "resolveClient", { enumerable: true, get: function () { return connection_1.resolveClient; } });
+Object.defineProperty(exports, "connectAutoServers", { enumerable: true, get: function () { return connection_1.connectAutoServers; } });
+Object.defineProperty(exports, "disconnectAll", { enumerable: true, get: function () { return connection_1.disconnectAll; } });
+Object.defineProperty(exports, "isConnected", { enumerable: true, get: function () { return connection_1.isConnected; } });
+Object.defineProperty(exports, "clear", { enumerable: true, get: function () { return connection_1.clear; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "callServerTool", { enumerable: true, get: function () { return tools_1.callServerTool; } });
+Object.defineProperty(exports, "toolActivities", { enumerable: true, get: function () { return tools_1.toolActivities; } });