@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

package/dist/mcp/client/manager.js

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-REMOTE-006: MCP Client Manager.
+ *
+ * Manages named MCP server connections with connect/disconnect lifecycle,
+ * status tracking, and optional reconnection. The manager does NOT directly
+ * depend on @modelcontextprotocol/sdk/client — instead it uses a pluggable
+ * transport factory so tests and consumers can inject their own.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClientManager = void 0;
+const config_1 = require("./config");
+/** Default delay (ms) between reconnection attempts. */
+const RECONNECT_BASE_DELAY_MS = 1000;
+// ---------------------------------------------------------------------------
+// McpClientManager
+// ---------------------------------------------------------------------------
+const defaultDelay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class McpClientManager {
+    _stateDir;
+    _transportFactory;
+    _delay;
+    _connections = new Map();
+    _initialized = false;
+    constructor(options) {
+        this._stateDir = options.stateDir;
+        this._transportFactory = options.transportFactory;
+        this._delay = options.delayFn ?? defaultDelay;
+    }
+    /** Initialize the manager: load server configs, optionally auto-connect. */
+    async initialize(autoConnect) {
+        const file = await (0, config_1.readMcpServersConfig)(this._stateDir);
+        for (const config of file.servers) {
+            this._connections.set(config.name, {
+                config,
+                connection: {
+                    name: config.name,
+                    status: "disconnected",
+                    lastStatusChange: new Date().toISOString(),
+                    reconnectAttempts: 0,
+                },
+                transport: undefined,
+                connectPromise: undefined,
+            });
+        }
+        this._initialized = true;
+        if (autoConnect) {
+            const autoServers = file.servers.filter((s) => s.autoConnect);
+            await Promise.allSettled(autoServers.map((s) => this.connect(s.name)));
+        }
+    }
+    /** Connect to a named server. Deduplicates concurrent connect attempts. */
+    async connect(serverName) {
+        const record = this._connections.get(serverName);
+        if (!record) {
+            throw new Error(`MCP server "${serverName}" not found in configuration`);
+        }
+        if (record.connection.status === "connected") {
+            return record.connection;
+        }
+        // Deduplicate in-flight connect attempts
+        if (record.connectPromise) {
+            return record.connectPromise;
+        }
+        record.connectPromise = this._doConnect(record);
+        try {
+            return await record.connectPromise;
+        }
+        finally {
+            record.connectPromise = undefined;
+        }
+    }
+    /**
+     * Attempt reconnection for a server that was previously connected.
+     * Retries up to maxReconnectAttempts with exponential backoff.
+     * Deduplicates concurrent reconnect calls.
+     * Returns the final connection state (may be 'error' if all retries exhausted).
+     */
+    async reconnect(serverName) {
+        const record = this._connections.get(serverName);
+        if (!record) {
+            throw new Error(`MCP server "${serverName}" not found in configuration`);
+        }
+        const maxAttempts = record.config.maxReconnectAttempts ?? 3;
+        if (!record.config.reconnect || maxAttempts <= 0) {
+            throw new Error(`Reconnection is not enabled for server "${serverName}"`);
+        }
+        // Deduplicate concurrent reconnect calls
+        if (record.connectPromise) {
+            return record.connectPromise;
+        }
+        record.connectPromise = this._doReconnect(record, maxAttempts);
+        try {
+            return await record.connectPromise;
+        }
+        finally {
+            record.connectPromise = undefined;
+        }
+    }
+    /** Disconnect from a named server. */
+    async disconnect(serverName) {
+        const record = this._connections.get(serverName);
+        if (!record) {
+            throw new Error(`MCP server "${serverName}" not found in configuration`);
+        }
+        if (record.transport) {
+            try {
+                await record.transport.disconnect();
+            }
+            catch {
+                // Best-effort disconnect
+            }
+            record.transport = undefined;
+        }
+        record.connectPromise = undefined;
+        this._setStatus(record, "disconnected");
+        record.connection.error = undefined;
+        return record.connection;
+    }
+    /** Disconnect all servers and release resources. */
+    async disconnectAll() {
+        const names = [...this._connections.keys()];
+        await Promise.allSettled(names.map((n) => this.disconnect(n)));
+    }
+    /** Get connection status for a named server. */
+    getConnection(serverName) {
+        return this._connections.get(serverName)?.connection;
+    }
+    /** List all tracked connections. */
+    listConnections() {
+        return [...this._connections.values()].map((r) => r.connection);
+    }
+    /** List tools available on a connected server. */
+    async listTools(serverName) {
+        const record = this._connections.get(serverName);
+        if (!record?.transport || record.connection.status !== "connected") {
+            throw new Error(`MCP server "${serverName}" is not connected`);
+        }
+        return record.transport.listTools();
+    }
+    /** Call a tool on a connected server. */
+    async callTool(serverName, toolName, args) {
+        const record = this._connections.get(serverName);
+        if (!record?.transport || record.connection.status !== "connected") {
+            throw new Error(`MCP server "${serverName}" is not connected`);
+        }
+        return record.transport.callTool(toolName, args);
+    }
+    /** Whether the manager has been initialized. */
+    get initialized() {
+        return this._initialized;
+    }
+    /** Get the config for a server. */
+    getServerConfig(serverName) {
+        return this._connections.get(serverName)?.config;
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    async _doReconnect(record, maxAttempts) {
+        this._setStatus(record, "reconnecting");
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            record.connection.reconnectAttempts = attempt;
+            // Exponential backoff: 1s, 2s, 4s, ...
+            const delayMs = RECONNECT_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+            await this._delay(delayMs);
+            const transport = this._transportFactory(record.config);
+            record.transport = transport;
+            try {
+                await transport.connect();
+                this._setStatus(record, "connected");
+                record.connection.connectedAt = new Date().toISOString();
+                record.connection.reconnectAttempts = 0;
+                record.connection.error = undefined;
+                return record.connection;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                record.connection.error = message;
+                record.transport = undefined;
+            }
+        }
+        // All retries exhausted
+        this._setStatus(record, "error");
+        process.stderr.write(`[babysitter] MCP reconnect failed for ${record.connection.name}: ${record.connection.error ?? 'unknown'}\n`);
+        return record.connection;
+    }
+    async _doConnect(record) {
+        this._setStatus(record, "connecting");
+        const transport = this._transportFactory(record.config);
+        record.transport = transport;
+        try {
+            await transport.connect();
+            this._setStatus(record, "connected");
+            record.connection.connectedAt = new Date().toISOString();
+            record.connection.reconnectAttempts = 0;
+            record.connection.error = undefined;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this._setStatus(record, "error");
+            record.connection.error = message;
+            record.transport = undefined;
+            throw err;
+        }
+        return record.connection;
+    }
+    _setStatus(record, status) {
+        record.connection.status = status;
+        record.connection.lastStatusChange = new Date().toISOString();
+    }
+}
+exports.McpClientManager = McpClientManager;

package/dist/mcp/client/resourceBrowser.d.ts

@@ -0,0 +1,52 @@
+/**
+ * MCP Resource Browser — list, read, and search resources exposed by MCP
+ * servers with a TTL-based cache (TOOLS-031).
+ *
+ * The browser wraps a transport-level resource fetch function and adds
+ * in-memory caching so repeated lookups within the TTL window avoid
+ * redundant round-trips.
+ */
+export interface McpResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface McpResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+/** Adapter function that the browser delegates to for actual I/O. */
+export interface ResourceFetcher {
+    listResources(): Promise<McpResource[]>;
+    readResource(uri: string): Promise<McpResourceContent>;
+}
+export interface McpResourceBrowserOptions {
+    /** Cache TTL in milliseconds. Default: 60 000 (1 minute). */
+    cacheTtlMs?: number;
+}
+export declare class McpResourceBrowser {
+    private readonly fetcher;
+    private readonly cacheTtlMs;
+    private listCache;
+    private readCache;
+    constructor(fetcher: ResourceFetcher, options?: McpResourceBrowserOptions);
+    /**
+     * List all resources. Results are cached for `cacheTtlMs`.
+     */
+    listResources(now?: number): Promise<McpResource[]>;
+    /**
+     * Read a single resource by URI. The result is cached per-URI for `cacheTtlMs`.
+     */
+    readResource(uri: string, now?: number): Promise<McpResourceContent>;
+    /**
+     * Search resources whose name or description contains the query string
+     * (case-insensitive). Operates on the cached list (fetching if stale).
+     */
+    searchResources(query: string, now?: number): Promise<McpResource[]>;
+    /** Invalidate all cached data. */
+    clearCache(): void;
+}
+//# sourceMappingURL=resourceBrowser.d.ts.map

package/dist/mcp/client/resourceBrowser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resourceBrowser.d.ts","sourceRoot":"","sources":["../../../src/mcp/client/resourceBrowser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC9B,aAAa,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACxC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,yBAAyB;IACxC,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAeD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,OAAO,CAAC,SAAS,CAA0C;IAC3D,OAAO,CAAC,SAAS,CAAqD;gBAE1D,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,yBAAyB;IASzE;;OAEG;IACG,aAAa,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAezD;;OAEG;IACG,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgB1E;;;OAGG;IACG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAc1E,kCAAkC;IAClC,UAAU,IAAI,IAAI;CAInB"}

package/dist/mcp/client/resourceBrowser.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * MCP Resource Browser — list, read, and search resources exposed by MCP
+ * servers with a TTL-based cache (TOOLS-031).
+ *
+ * The browser wraps a transport-level resource fetch function and adds
+ * in-memory caching so repeated lookups within the TTL window avoid
+ * redundant round-trips.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpResourceBrowser = void 0;
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+class McpResourceBrowser {
+    fetcher;
+    cacheTtlMs;
+    listCache = null;
+    readCache = new Map();
+    constructor(fetcher, options) {
+        this.fetcher = fetcher;
+        this.cacheTtlMs = options?.cacheTtlMs ?? 60_000;
+    }
+    // -------------------------------------------------------------------------
+    // List
+    // -------------------------------------------------------------------------
+    /**
+     * List all resources. Results are cached for `cacheTtlMs`.
+     */
+    async listResources(now) {
+        const ts = now ?? Date.now();
+        if (this.listCache && this.listCache.expiresAt > ts) {
+            return this.listCache.value;
+        }
+        const resources = await this.fetcher.listResources();
+        this.listCache = { value: resources, expiresAt: ts + this.cacheTtlMs };
+        return resources;
+    }
+    // -------------------------------------------------------------------------
+    // Read
+    // -------------------------------------------------------------------------
+    /**
+     * Read a single resource by URI. The result is cached per-URI for `cacheTtlMs`.
+     */
+    async readResource(uri, now) {
+        const ts = now ?? Date.now();
+        const cached = this.readCache.get(uri);
+        if (cached && cached.expiresAt > ts) {
+            return cached.value;
+        }
+        const content = await this.fetcher.readResource(uri);
+        this.readCache.set(uri, { value: content, expiresAt: ts + this.cacheTtlMs });
+        return content;
+    }
+    // -------------------------------------------------------------------------
+    // Search
+    // -------------------------------------------------------------------------
+    /**
+     * Search resources whose name or description contains the query string
+     * (case-insensitive). Operates on the cached list (fetching if stale).
+     */
+    async searchResources(query, now) {
+        const resources = await this.listResources(now);
+        const lowerQuery = query.toLowerCase();
+        return resources.filter((r) => {
+            const nameMatch = r.name.toLowerCase().includes(lowerQuery);
+            const descMatch = r.description?.toLowerCase().includes(lowerQuery) ?? false;
+            return nameMatch || descMatch;
+        });
+    }
+    // -------------------------------------------------------------------------
+    // Cache management
+    // -------------------------------------------------------------------------
+    /** Invalidate all cached data. */
+    clearCache() {
+        this.listCache = null;
+        this.readCache.clear();
+    }
+}
+exports.McpResourceBrowser = McpResourceBrowser;

package/dist/mcp/client/toolRegistry.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-TOOLS-025: MCP Tool Registry.
+ *
+ * Maintains a cached index of tools across all connected MCP servers.
+ * Supports refresh, search, and lookup by qualified name (server:tool).
+ */
+import type { McpToolInfo } from "./types";
+import type { McpClientManager } from "./manager";
+export interface McpToolRegistryOptions {
+    /** TTL for cached tool listings (ms). 0 = never expire (infinite cache). Default: 60000. */
+    cacheTtlMs?: number;
+    unifiedRegistry?: UnifiedToolRegistryLike;
+    mcpBridge?: McpBridgeLike;
+}
+interface UnifiedToolRegistryLike {
+    registerServer(server: {
+        id: string;
+        name: string;
+        type: "mcp";
+        tools: Array<{
+            name: string;
+            description?: string;
+            parameters?: Record<string, unknown>;
+            source: "mcp";
+            sourceQualifier?: string;
+            server?: string;
+        }>;
+    }): void;
+    unregisterServer?(serverId: string, removeTools?: boolean): boolean;
+    list?(): Array<{
+        name: string;
+        description?: string;
+        source: string;
+        sourceQualifier?: string;
+        server?: string;
+    }>;
+    listByServer?(serverId: string): Array<{
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+        source: string;
+        sourceQualifier?: string;
+        server?: string;
+    }>;
+    searchTools?(query: string): Array<{
+        name: string;
+        description?: string;
+        source: string;
+        sourceQualifier?: string;
+    }>;
+    get?(name: string, source?: "mcp", sourceQualifier?: string): {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+        source: string;
+        sourceQualifier?: string;
+        server?: string;
+    } | undefined;
+}
+interface McpBridgeLike {
+    registerServer(config: {
+        id: string;
+        name: string;
+        transport: "stdio";
+    }, tools: Array<{
+        name: string;
+        description?: string;
+        inputSchema?: Record<string, unknown>;
+    }>): void;
+    unregisterServer?(serverId: string): void;
+}
+export declare class McpToolRegistry {
+    private readonly _manager;
+    private readonly _cacheTtlMs;
+    private readonly _unifiedRegistry;
+    private readonly _mcpBridge;
+    private readonly _cache;
+    constructor(manager: McpClientManager, options?: McpToolRegistryOptions);
+    /**
+     * Refresh tool listings from all connected servers.
+     * Returns the total number of tools indexed.
+     */
+    refreshAll(): Promise<number>;
+    /** Refresh tools for a specific server. */
+    refreshServer(serverName: string): Promise<McpToolInfo[]>;
+    /**
+     * Get all known tools across all servers.
+     * Returns cached data when available and not expired.
+     */
+    getAllTools(): McpToolInfo[];
+    /** Get tools for a specific server from cache. */
+    getToolsForServer(serverName: string): McpToolInfo[];
+    /**
+     * Search tools by name or description substring (case-insensitive).
+     * Searches across all cached servers.
+     */
+    searchTools(query: string): McpToolInfo[];
+    /**
+     * Look up a tool by qualified name "serverName:toolName".
+     * Returns undefined if not found in cache.
+     */
+    getToolByQualifiedName(qualifiedName: string): McpToolInfo | undefined;
+    /** Clear the entire cache. */
+    clearCache(): void;
+    /** Number of non-expired tools currently in cache (across all servers). */
+    get cachedToolCount(): number;
+    private _isExpired;
+    private _registerUnifiedServer;
+}
+export {};
+//# sourceMappingURL=toolRegistry.d.ts.map

package/dist/mcp/client/toolRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolRegistry.d.ts","sourceRoot":"","sources":["../../../src/mcp/client/toolRegistry.ts"],"names":[],"mappings":"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"}

package/dist/mcp/client/toolRegistry.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ * Moved from @a5c-ai/babysitter-sdk.
+ * GAP-TOOLS-025: MCP Tool Registry.
+ *
+ * Maintains a cached index of tools across all connected MCP servers.
+ * Supports refresh, search, and lookup by qualified name (server:tool).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpToolRegistry = void 0;
+// ---------------------------------------------------------------------------
+// McpToolRegistry
+// ---------------------------------------------------------------------------
+class McpToolRegistry {
+    _manager;
+    _cacheTtlMs;
+    _unifiedRegistry;
+    _mcpBridge;
+    _cache = new Map();
+    constructor(manager, options) {
+        this._manager = manager;
+        this._cacheTtlMs = options?.cacheTtlMs ?? 60_000;
+        this._unifiedRegistry = options?.unifiedRegistry;
+        this._mcpBridge = options?.mcpBridge;
+    }
+    /**
+     * Refresh tool listings from all connected servers.
+     * Returns the total number of tools indexed.
+     */
+    async refreshAll() {
+        const connections = this._manager.listConnections();
+        let total = 0;
+        for (const conn of connections) {
+            if (conn.status !== "connected")
+                continue;
+            try {
+                const tools = await this._manager.listTools(conn.name);
+                this._cache.set(conn.name, { tools, fetchedAt: Date.now() });
+                this._registerUnifiedServer(conn.name, tools);
+                total += tools.length;
+            }
+            catch {
+                // Skip servers that fail to list tools
+            }
+        }
+        return total;
+    }
+    /** Refresh tools for a specific server. */
+    async refreshServer(serverName) {
+        const tools = await this._manager.listTools(serverName);
+        this._cache.set(serverName, { tools, fetchedAt: Date.now() });
+        this._registerUnifiedServer(serverName, tools);
+        return tools;
+    }
+    /**
+     * Get all known tools across all servers.
+     * Returns cached data when available and not expired.
+     */
+    getAllTools() {
+        if (this._unifiedRegistry?.list) {
+            return this._unifiedRegistry.list()
+                .filter((tool) => tool.source === "mcp")
+                .map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: undefined,
+                serverName: tool.sourceQualifier ?? tool.server ?? "",
+            }));
+        }
+        const result = [];
+        for (const cached of this._cache.values()) {
+            if (this._isExpired(cached))
+                continue;
+            result.push(...cached.tools);
+        }
+        return result;
+    }
+    /** Get tools for a specific server from cache. */
+    getToolsForServer(serverName) {
+        const unifiedTools = this._unifiedRegistry?.listByServer?.(serverName);
+        if (unifiedTools) {
+            return unifiedTools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.parameters,
+                serverName,
+            }));
+        }
+        const cached = this._cache.get(serverName);
+        if (!cached || this._isExpired(cached))
+            return [];
+        return cached.tools;
+    }
+    /**
+     * Search tools by name or description substring (case-insensitive).
+     * Searches across all cached servers.
+     */
+    searchTools(query) {
+        const unifiedMatches = this._unifiedRegistry?.searchTools?.(query);
+        if (unifiedMatches) {
+            return unifiedMatches
+                .filter((tool) => tool.source === "mcp")
+                .map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: undefined,
+                serverName: tool.sourceQualifier ?? "",
+            }));
+        }
+        const lower = query.toLowerCase();
+        const all = this.getAllTools();
+        return all.filter((t) => t.name.toLowerCase().includes(lower) ||
+            (t.description?.toLowerCase().includes(lower) ?? false));
+    }
+    /**
+     * Look up a tool by qualified name "serverName:toolName".
+     * Returns undefined if not found in cache.
+     */
+    getToolByQualifiedName(qualifiedName) {
+        const colonIdx = qualifiedName.indexOf(":");
+        if (colonIdx < 0) {
+            // Unqualified: search all servers
+            return this.getAllTools().find((t) => t.name === qualifiedName);
+        }
+        const serverName = qualifiedName.slice(0, colonIdx);
+        const toolName = qualifiedName.slice(colonIdx + 1);
+        const unifiedTool = this._unifiedRegistry?.get?.(toolName, "mcp", serverName);
+        if (unifiedTool) {
+            return {
+                name: unifiedTool.name,
+                description: unifiedTool.description,
+                inputSchema: unifiedTool.parameters,
+                serverName,
+            };
+        }
+        const tools = this.getToolsForServer(serverName);
+        return tools.find((t) => t.name === toolName);
+    }
+    /** Clear the entire cache. */
+    clearCache() {
+        for (const serverName of this._cache.keys()) {
+            this._unifiedRegistry?.unregisterServer?.(serverName, true);
+            this._mcpBridge?.unregisterServer?.(serverName);
+        }
+        this._cache.clear();
+    }
+    /** Number of non-expired tools currently in cache (across all servers). */
+    get cachedToolCount() {
+        let count = 0;
+        for (const cached of this._cache.values()) {
+            if (this._isExpired(cached))
+                continue;
+            count += cached.tools.length;
+        }
+        return count;
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    _isExpired(cached) {
+        if (this._cacheTtlMs <= 0)
+            return false; // 0 = never expire
+        return Date.now() - cached.fetchedAt > this._cacheTtlMs;
+    }
+    _registerUnifiedServer(serverName, tools) {
+        this._mcpBridge?.registerServer({ id: serverName, name: serverName, transport: "stdio" }, tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+        })));
+        if (this._mcpBridge || !this._unifiedRegistry) {
+            return;
+        }
+        this._unifiedRegistry.registerServer({
+            id: serverName,
+            name: serverName,
+            type: "mcp",
+            tools: tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.inputSchema,
+                source: "mcp",
+                sourceQualifier: serverName,
+                server: serverName,
+            })),
+        });
+    }
+}
+exports.McpToolRegistry = McpToolRegistry;