@hotmeshio/long-tail 0.1.14 → 0.1.15

package/build/routes/knowledge.js

@@ -0,0 +1,141 @@
+"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 });
+const express_1 = require("express");
+const api = __importStar(require("../api/knowledge"));
+const router = (0, express_1.Router)();
+/**
+ * GET /api/knowledge/domains
+ * List all knowledge domains with entry counts.
+ */
+router.get('/domains', async (_req, res) => {
+    const result = await api.listDomains();
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * GET /api/knowledge/entries
+ * List entries within a domain.
+ * Query: ?domain=...&tags=a,b&limit=50&offset=0
+ */
+router.get('/entries', async (req, res) => {
+    const domain = req.query.domain;
+    if (!domain) {
+        res.status(400).json({ error: 'domain is required' });
+        return;
+    }
+    const tags = req.query.tags
+        ? req.query.tags.split(',').map((t) => t.trim()).filter(Boolean)
+        : undefined;
+    const search = req.query.search || undefined;
+    const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+    const offset = req.query.offset ? parseInt(req.query.offset, 10) : undefined;
+    const result = await api.listEntries({ domain, tags, search, limit, offset });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * GET /api/knowledge/entry
+ * Get a single knowledge entry.
+ * Query: ?domain=...&key=...
+ */
+router.get('/entry', async (req, res) => {
+    const domain = req.query.domain;
+    const key = req.query.key;
+    if (!domain || !key) {
+        res.status(400).json({ error: 'domain and key are required' });
+        return;
+    }
+    const result = await api.getEntry({ domain, key });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * POST /api/knowledge/entry
+ * Create or update a knowledge entry.
+ * Body: { domain, key, data, tags? }
+ */
+router.post('/entry', async (req, res) => {
+    const { domain, key, data, tags, replace } = req.body;
+    if (!domain || !key || !data) {
+        res.status(400).json({ error: 'domain, key, and data are required' });
+        return;
+    }
+    const result = await api.storeEntry({ domain, key, data, tags, replace: !!replace });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * DELETE /api/knowledge/entry
+ * Delete a knowledge entry.
+ * Query: ?domain=...&key=...
+ */
+router.delete('/entry', async (req, res) => {
+    const domain = req.query.domain;
+    const key = req.query.key;
+    if (!domain || !key) {
+        res.status(400).json({ error: 'domain and key are required' });
+        return;
+    }
+    const result = await api.deleteEntry({ domain, key });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * PUT /api/knowledge/field
+ * Set a value at a specific JSONB path without clobbering siblings.
+ * Body: { domain, key, path, value, tags? }
+ */
+router.put('/field', async (req, res) => {
+    const { domain, key, path, value, tags } = req.body;
+    if (!domain || !key || !path || value === undefined) {
+        res.status(400).json({ error: 'domain, key, path, and value are required' });
+        return;
+    }
+    const result = await api.setField({ domain, key, path, value, tags });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+/**
+ * DELETE /api/knowledge/field
+ * Remove a specific field at a JSONB path.
+ * Query: ?domain=...&key=...&path=...
+ */
+router.delete('/field', async (req, res) => {
+    const domain = req.query.domain;
+    const key = req.query.key;
+    const path = req.query.path;
+    if (!domain || !key || !path) {
+        res.status(400).json({ error: 'domain, key, and path are required' });
+        return;
+    }
+    const result = await api.removeField({ domain, key, path });
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
+exports.default = router;

package/build/routes/yaml-workflows/crud.js

@@ -80,6 +80,15 @@ router.post('/direct', async (req, res) => {
     const result = await api.createYamlWorkflowDirect(req.body);
     res.status(result.status).json(result.data ?? { error: result.error });
 });
+/**
+ * POST /api/yaml-workflows/from-durable
+ * Compile a durable TypeScript workflow into a YAML DAG.
+ * Body: { source, is_file_path?, workflow_name, name, description?, app_id?, subscribes?, tags? }
+ */
+router.post('/from-durable', async (req, res) => {
+    const result = await api.createYamlWorkflowFromDurable(req.body);
+    res.status(result.status).json(result.data ?? { error: result.error });
+});
 // -- Parameterized routes --
 /**
  * GET /api/yaml-workflows/:id

package/build/sdk/index.d.ts

@@ -16,6 +16,8 @@ import * as workflowSetsApi from '../api/workflow-sets';
 import * as dbaApi from '../api/dba';
 import * as namespacesApi from '../api/namespaces';
 import * as maintenanceApi from '../api/maintenance';
+import * as filesApi from '../api/files';
+import * as knowledgeApi from '../api/knowledge';
 import type { LTApiAuth, LTApiResult } from '../types/sdk';
 import type { LTEvent, LTEventType } from '../types/events';
 /**
@@ -330,6 +332,21 @@ export declare function createClient(options?: LTClientOptions): {
         getConfig: typeof maintenanceApi.getMaintenanceConfig;
         updateConfig: typeof maintenanceApi.updateMaintenanceConfig;
     };
+    files: {
+        browse: typeof filesApi.browseFiles;
+        getMetadata: typeof filesApi.getFileMetadata;
+        delete: typeof filesApi.deleteFile;
+        generateSignedUrl: typeof filesApi.generateSignedUrl;
+    };
+    knowledge: {
+        listDomains: typeof knowledgeApi.listDomains;
+        listEntries: typeof knowledgeApi.listEntries;
+        getEntry: typeof knowledgeApi.getEntry;
+        storeEntry: typeof knowledgeApi.storeEntry;
+        setField: typeof knowledgeApi.setField;
+        removeField: typeof knowledgeApi.removeField;
+        deleteEntry: typeof knowledgeApi.deleteEntry;
+    };
     events: {
         /**
          * Subscribe to Long Tail events.

package/build/sdk/index.js

@@ -52,6 +52,8 @@ const workflowSetsApi = __importStar(require("../api/workflow-sets"));
 const dbaApi = __importStar(require("../api/dba"));
 const namespacesApi = __importStar(require("../api/namespaces"));
 const maintenanceApi = __importStar(require("../api/maintenance"));
+const filesApi = __importStar(require("../api/files"));
+const knowledgeApi = __importStar(require("../api/knowledge"));
 const events_1 = require("../lib/events");
 const callback_1 = require("../lib/events/callback");
 /** Bind auth context to a function that expects it as the last argument. */
@@ -275,6 +277,23 @@ function createClient(options = {}) {
             getConfig: maintenanceApi.getMaintenanceConfig,
             updateConfig: maintenanceApi.updateMaintenanceConfig,
         },
+        // ── Files ──────────────────────────────────────────────────────────────
+        files: {
+            browse: filesApi.browseFiles,
+            getMetadata: filesApi.getFileMetadata,
+            delete: filesApi.deleteFile,
+            generateSignedUrl: filesApi.generateSignedUrl,
+        },
+        // ── Knowledge ─────────────────────────────────────────────────────────
+        knowledge: {
+            listDomains: knowledgeApi.listDomains,
+            listEntries: knowledgeApi.listEntries,
+            getEntry: knowledgeApi.getEntry,
+            storeEntry: knowledgeApi.storeEntry,
+            setField: knowledgeApi.setField,
+            removeField: knowledgeApi.removeField,
+            deleteEntry: knowledgeApi.deleteEntry,
+        },
         // ── Events ─────────────────────────────────────────────────────────────
         events: {
             /**

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

@@ -0,0 +1,18 @@
+import type { LTMcpToolManifest } from '../../../types';
+/**
+ * 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.
+ */
+export declare function dispatchBuiltinTool(serverId: string, toolName: string, args: Record<string, any>): Promise<{
+    dispatched: true;
+    result: any;
+} | null>;
+/**
+ * List tools from a connected server.
+ */
+export declare function listServerTools(serverId: string): Promise<LTMcpToolManifest[]>;

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispatchBuiltinTool = dispatchBuiltinTool;
+exports.listServerTools = listServerTools;
+const logger_1 = require("../../../lib/logger");
+const connection_lifecycle_1 = require("./connection-lifecycle");
+/**
+ * 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) {
+    const builtinFactories = (0, connection_lifecycle_1.getBuiltinFactories)();
+    const builtinServers = (0, connection_lifecycle_1.getBuiltinServers)();
+    // 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 };
+}
+/**
+ * List tools from a connected server.
+ */
+async function listServerTools(serverId) {
+    const clients = (0, connection_lifecycle_1.getClients)();
+    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 || {},
+    }));
+}

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

@@ -0,0 +1,48 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { LTMcpServerRecord } from '../../../types';
+/** Read-only access to the clients map for sibling modules. */
+export declare function getClients(): Map<string, Client>;
+/** Read-only access to the builtin factories map for sibling modules. */
+export declare function getBuiltinFactories(): Map<string, () => Promise<any>>;
+/** Read-only access to the builtin servers map for sibling modules. */
+export declare function getBuiltinServers(): Map<string, any>;
+/**
+ * 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. 'translation' matching 'long-tail-translation') 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>;
+/**
+ * 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-lifecycle.js

@@ -0,0 +1,296 @@
+"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.getClients = getClients;
+exports.getBuiltinFactories = getBuiltinFactories;
+exports.getBuiltinServers = getBuiltinServers;
+exports.registerBuiltinServer = registerBuiltinServer;
+exports.connectToServer = connectToServer;
+exports.disconnectFromServer = disconnectFromServer;
+exports.resolveClient = resolveClient;
+exports.connectAutoServers = connectAutoServers;
+exports.disconnectAll = disconnectAll;
+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 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();
+/** Read-only access to the clients map for sibling modules. */
+function getClients() {
+    return clients;
+}
+/** Read-only access to the builtin factories map for sibling modules. */
+function getBuiltinFactories() {
+    return builtinFactories;
+}
+/** Read-only access to the builtin servers map for sibling modules. */
+function getBuiltinServers() {
+    return builtinServers;
+}
+/**
+ * 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;
+    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);
+    }
+}
+/**
+ * Check if a server is connected.
+ */
+function isConnected(serverId) {
+    return clients.has(serverId);
+}
+/**
+ * Clear all state. Used in tests.
+ */
+function clear() {
+    clients.clear();
+    builtinServers.clear();
+}

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

@@ -0,0 +1,10 @@
+import type { LTMcpToolManifest } from '../../../types';
+/**
+ * Test connectivity to an MCP server without persisting.
+ * Creates a temporary client, connects, lists tools, then disconnects.
+ */
+export declare function testConnection(transportType: 'stdio' | 'sse' | 'streamable-http', transportConfig: Record<string, any>): Promise<{
+    success: boolean;
+    tools: LTMcpToolManifest[];
+    error?: string;
+}>;