@hotmeshio/long-tail 0.1.13 → 0.1.15

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

@@ -1,395 +1,17 @@
 "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.dispatchBuiltinTool = dispatchBuiltinTool;
-exports.connectToServer = connectToServer;
-exports.disconnectFromServer = disconnectFromServer;
-exports.resolveClient = resolveClient;
-exports.connectAutoServers = connectAutoServers;
-exports.disconnectAll = disconnectAll;
-exports.listServerTools = listServerTools;
-exports.isConnected = isConnected;
-exports.testConnection = testConnection;
-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 streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-const inMemory_js_1 = require("@modelcontextprotocol/sdk/inMemory.js");
-const logger_1 = require("../../../lib/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();
-/**
- * Cached built-in McpServer instances -- keyed by canonical server name.
- * Used by dispatchBuiltinTool() to call tool handlers directly without
- * going through MCP Client/Transport. One instance per server.
- */
-const builtinServers = 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);
-}
-/**
- * Dispatch a tool call directly to a built-in server's handler,
- * bypassing MCP Client/Transport entirely. Returns null if the server
- * or tool is not a built-in — caller should fall through to MCP transport.
- *
- * Each built-in server is lazily instantiated once and cached. Tool handlers
- * are called via server._registeredTools[toolName].handler(args). This
- * eliminates the InMemoryTransport bottleneck under concurrent load.
- */
-async function dispatchBuiltinTool(serverId, toolName, args) {
-    // Normalize and match against builtin factories
-    const norm = (s) => s.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
-    const normId = norm(serverId);
-    let matchedName = null;
-    for (const [name] of builtinFactories) {
-        const normName = norm(name);
-        if (normName === normId || normName.includes(normId) || normId.includes(normName)) {
-            matchedName = name;
-            break;
-        }
-    }
-    if (!matchedName)
-        return null;
-    // Lazily create and cache the server instance
-    if (!builtinServers.has(matchedName)) {
-        const factory = builtinFactories.get(matchedName);
-        const server = await factory();
-        builtinServers.set(matchedName, server);
-        logger_1.loggerRegistry.info(`[lt-mcp:builtin] ${matchedName} ready (direct dispatch)`);
-    }
-    const server = builtinServers.get(matchedName);
-    const tool = server._registeredTools?.[toolName];
-    if (!tool?.handler)
-        return null;
-    // Call the handler directly — no transport, no JSON-RPC.
-    // Tool handlers return MCP-shaped responses: { content: [{ type: 'text', text: '...' }] }
-    // Parse the text content the same way callServerTool does.
-    const mcpResponse = await tool.handler(args);
-    let parsed = mcpResponse;
-    if (mcpResponse && Array.isArray(mcpResponse.content)) {
-        const textContent = mcpResponse.content.find((c) => c.type === 'text');
-        if (textContent && 'text' in textContent) {
-            try {
-                parsed = JSON.parse(textContent.text);
-            }
-            catch {
-                parsed = mcpResponse.isError ? { error: textContent.text } : textContent.text;
-            }
-        }
-    }
-    const isError = parsed && typeof parsed === 'object' && 'error' in parsed;
-    logger_1.loggerRegistry.debug(`[lt-mcp:builtin] ${matchedName}/${toolName} ok=${!isError} resultKeys=[${typeof parsed === 'object' && parsed ? Object.keys(parsed).join(',') : 'raw'}]`);
-    return { dispatched: true, result: parsed };
-}
-/**
- * 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;
-    const ttype = server.transport_type;
-    if (ttype === 'stdio') {
-        transport = new stdio_js_1.StdioClientTransport({
-            command: server.transport_config.command,
-            args: server.transport_config.args || [],
-            env: server.transport_config.env,
-        });
-    }
-    else if (ttype === 'streamable-http') {
-        transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(server.transport_config.url));
-    }
-    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. 'translation' matching 'long-tail-translation') 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
-    //    Normalize strips non-alphanumeric chars so hyphens and underscores
-    //    match (e.g., "long_tail_vision" matches "long-tail-vision").
-    const norm = (s) => s.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
-    let matchedName = null;
-    if (builtinFactories.has(serverId)) {
-        matchedName = serverId;
-    }
-    else {
-        const normId = norm(serverId);
-        for (const [name] of builtinFactories) {
-            const normName = norm(name);
-            if (normName.includes(normId) || normId.includes(normName)) {
-                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);
-}
-/**
- * Test connectivity to an MCP server without persisting.
- * Creates a temporary client, connects, lists tools, then disconnects.
- */
-async function testConnection(transportType, transportConfig) {
-    const client = new index_js_1.Client({ name: 'long-tail-test', version: '1.0.0' });
-    const timeout = setTimeout(() => { throw new Error('Connection timed out (10s)'); }, 10_000);
-    try {
-        let transport;
-        if (transportType === 'stdio') {
-            transport = new stdio_js_1.StdioClientTransport({
-                command: transportConfig.command,
-                args: transportConfig.args || [],
-                env: transportConfig.env,
-            });
-        }
-        else if (transportType === 'streamable-http') {
-            transport = new streamableHttp_js_1.StreamableHTTPClientTransport(new URL(transportConfig.url));
-        }
-        else {
-            transport = new sse_js_1.SSEClientTransport(new URL(transportConfig.url));
-        }
-        await client.connect(transport);
-        const { tools } = await client.listTools();
-        const manifest = tools.map((t) => ({
-            name: t.name,
-            description: t.description || '',
-            inputSchema: t.inputSchema || {},
-        }));
-        return { success: true, tools: manifest };
-    }
-    catch (err) {
-        return { success: false, tools: [], error: err.message };
-    }
-    finally {
-        clearTimeout(timeout);
-        try {
-            await client.close();
-        }
-        catch { /* ignore close errors */ }
-    }
-}
-/**
- * Clear all state. Used in tests.
- */
-function clear() {
-    clients.clear();
-    builtinServers.clear();
-}
+exports.listServerTools = exports.dispatchBuiltinTool = exports.testConnection = exports.clear = exports.isConnected = exports.disconnectAll = exports.connectAutoServers = exports.resolveClient = exports.disconnectFromServer = exports.connectToServer = exports.registerBuiltinServer = void 0;
+var connection_lifecycle_1 = require("./connection-lifecycle");
+Object.defineProperty(exports, "registerBuiltinServer", { enumerable: true, get: function () { return connection_lifecycle_1.registerBuiltinServer; } });
+Object.defineProperty(exports, "connectToServer", { enumerable: true, get: function () { return connection_lifecycle_1.connectToServer; } });
+Object.defineProperty(exports, "disconnectFromServer", { enumerable: true, get: function () { return connection_lifecycle_1.disconnectFromServer; } });
+Object.defineProperty(exports, "resolveClient", { enumerable: true, get: function () { return connection_lifecycle_1.resolveClient; } });
+Object.defineProperty(exports, "connectAutoServers", { enumerable: true, get: function () { return connection_lifecycle_1.connectAutoServers; } });
+Object.defineProperty(exports, "disconnectAll", { enumerable: true, get: function () { return connection_lifecycle_1.disconnectAll; } });
+Object.defineProperty(exports, "isConnected", { enumerable: true, get: function () { return connection_lifecycle_1.isConnected; } });
+Object.defineProperty(exports, "clear", { enumerable: true, get: function () { return connection_lifecycle_1.clear; } });
+var connection_test_1 = require("./connection-test");
+Object.defineProperty(exports, "testConnection", { enumerable: true, get: function () { return connection_test_1.testConnection; } });
+var connection_dispatch_1 = require("./connection-dispatch");
+Object.defineProperty(exports, "dispatchBuiltinTool", { enumerable: true, get: function () { return connection_dispatch_1.dispatchBuiltinTool; } });
+Object.defineProperty(exports, "listServerTools", { enumerable: true, get: function () { return connection_dispatch_1.listServerTools; } });

package/build/services/mcp/server-lifecycle.d.ts

@@ -0,0 +1,27 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create the Long Tail Human Queue MCP server.
+ *
+ * Registers six tools that expose the escalation API:
+ * - escalate_to_human -- create a new escalation (fire-and-forget)
+ * - check_resolution -- check escalation status
+ * - get_available_work -- list available escalations by role
+ * - claim_and_resolve -- claim + resolve in one step
+ * - resolve_escalation -- resolve an already-claimed escalation
+ * - escalate_and_wait -- create escalation and return signal for durable wait
+ *
+ * The server is created with tools registered but no transport
+ * auto-connected. Callers connect a transport programmatically
+ * or via the Streamable HTTP endpoint.
+ */
+export declare function createHumanQueueServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+/**
+ * Get the current MCP server instance.
+ */
+export declare function getServer(): McpServer | null;
+/**
+ * Stop the MCP server and release resources.
+ */
+export declare function stopServer(): Promise<void>;

package/build/services/mcp/server-lifecycle.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHumanQueueServer = createHumanQueueServer;
+exports.getServer = getServer;
+exports.stopServer = stopServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_1 = require("../../lib/logger");
+const server_tools_1 = require("./server-tools");
+let server = null;
+/**
+ * Create the Long Tail Human Queue MCP server.
+ *
+ * Registers six tools that expose the escalation API:
+ * - escalate_to_human -- create a new escalation (fire-and-forget)
+ * - check_resolution -- check escalation status
+ * - get_available_work -- list available escalations by role
+ * - claim_and_resolve -- claim + resolve in one step
+ * - resolve_escalation -- resolve an already-claimed escalation
+ * - escalate_and_wait -- create escalation and return signal for durable wait
+ *
+ * The server is created with tools registered but no transport
+ * auto-connected. Callers connect a transport programmatically
+ * or via the Streamable HTTP endpoint.
+ */
+async function createHumanQueueServer(options) {
+    if (server)
+        return server;
+    const name = options?.name || 'long-tail-human-queue';
+    server = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    (0, server_tools_1.registerHumanQueueTools)(server);
+    logger_1.loggerRegistry.info(`[lt-mcp:server] ${name} ready (5 tools registered)`);
+    return server;
+}
+/**
+ * Get the current MCP server instance.
+ */
+function getServer() {
+    return server;
+}
+/**
+ * Stop the MCP server and release resources.
+ */
+async function stopServer() {
+    if (server) {
+        await server.close();
+        server = null;
+        logger_1.loggerRegistry.info('[lt-mcp:server] stopped');
+    }
+}

package/build/services/mcp/server-tools.d.ts

@@ -0,0 +1,13 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register all human queue tools on the given MCP server.
+ *
+ * Tools registered:
+ * - escalate_to_human -- create a new escalation (fire-and-forget)
+ * - check_resolution -- check escalation status
+ * - get_available_work -- list available escalations by role
+ * - claim_and_resolve -- claim + resolve in one step
+ * - resolve_escalation -- resolve an already-claimed escalation
+ * - escalate_and_wait -- create escalation and return signal for durable wait
+ */
+export declare function registerHumanQueueTools(server: McpServer): void;