@rainfall-devkit/sdk 0.2.0 → 0.2.1

package/dist/daemon/index.js

@@ -40,12 +40,16 @@ var init_cjs_shims = __esm({
 // src/cli/config.ts
 var config_exports = {};
 __export(config_exports, {
+  getConfigDir: () => getConfigDir,
   getLLMConfig: () => getLLMConfig,
   getProviderBaseUrl: () => getProviderBaseUrl,
   isLocalProvider: () => isLocalProvider,
   loadConfig: () => loadConfig,
   saveConfig: () => saveConfig
 });
+function getConfigDir() {
+  return CONFIG_DIR;
+}
 function loadConfig() {
   let config = {};
   if ((0, import_fs.existsSync)(CONFIG_FILE)) {
@@ -110,6 +114,7 @@ function getProviderBaseUrl(config) {
     case "ollama":
       return config.llm?.baseUrl || "http://localhost:11434/v1";
     case "local":
+    case "custom":
       return config.llm?.baseUrl || "http://localhost:1234/v1";
     case "rainfall":
     default:
@@ -132,6 +137,7 @@ var init_config = __esm({
 // src/daemon/index.ts
 var daemon_exports = {};
 __export(daemon_exports, {
+  MCPProxyHub: () => MCPProxyHub,
   RainfallDaemon: () => RainfallDaemon,
   getDaemonInstance: () => getDaemonInstance,
   getDaemonStatus: () => getDaemonStatus,
@@ -140,7 +146,7 @@ __export(daemon_exports, {
 });
 module.exports = __toCommonJS(daemon_exports);
 init_cjs_shims();
-var import_ws = require("ws");
+var import_ws2 = require("ws");
 var import_express = __toESM(require("express"));
 
 // src/sdk.ts
@@ -1645,6 +1651,566 @@ var RainfallListenerRegistry = class {
   }
 };
 
+// src/services/mcp-proxy.ts
+init_cjs_shims();
+var import_ws = require("ws");
+var import_client2 = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+var MCPProxyHub = class {
+  clients = /* @__PURE__ */ new Map();
+  options;
+  refreshTimer;
+  reconnectTimeouts = /* @__PURE__ */ new Map();
+  requestId = 0;
+  constructor(options = {}) {
+    this.options = {
+      debug: options.debug ?? false,
+      autoReconnect: options.autoReconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 5e3,
+      toolTimeout: options.toolTimeout ?? 3e4,
+      refreshInterval: options.refreshInterval ?? 3e4
+    };
+  }
+  /**
+   * Initialize the MCP proxy hub
+   */
+  async initialize() {
+    this.log("\u{1F50C} Initializing MCP Proxy Hub...");
+    this.startRefreshTimer();
+    this.log("\u2705 MCP Proxy Hub initialized");
+  }
+  /**
+   * Shutdown the MCP proxy hub and disconnect all clients
+   */
+  async shutdown() {
+    this.log("\u{1F6D1} Shutting down MCP Proxy Hub...");
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = void 0;
+    }
+    for (const timeout of this.reconnectTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.reconnectTimeouts.clear();
+    const disconnectPromises = Array.from(this.clients.entries()).map(
+      async ([name, client]) => {
+        try {
+          await this.disconnectClient(name);
+        } catch (error) {
+          this.log(`Error disconnecting ${name}:`, error);
+        }
+      }
+    );
+    await Promise.allSettled(disconnectPromises);
+    this.clients.clear();
+    this.log("\u{1F44B} MCP Proxy Hub shut down");
+  }
+  /**
+   * Connect to an MCP server
+   */
+  async connectClient(config) {
+    const { name, transport } = config;
+    if (this.clients.has(name)) {
+      this.log(`Reconnecting client: ${name}`);
+      await this.disconnectClient(name);
+    }
+    this.log(`Connecting to MCP server: ${name} (${transport})...`);
+    try {
+      const client = new import_client2.Client(
+        {
+          name: `rainfall-daemon-${name}`,
+          version: "0.2.0"
+        },
+        {
+          capabilities: {}
+        }
+      );
+      let lastErrorTime = 0;
+      client.onerror = (error) => {
+        const now = Date.now();
+        if (now - lastErrorTime > 5e3) {
+          this.log(`MCP Server Error (${name}):`, error.message);
+          lastErrorTime = now;
+        }
+        if (this.options.autoReconnect) {
+          this.scheduleReconnect(name, config);
+        }
+      };
+      let transportInstance;
+      if (transport === "stdio" && config.command) {
+        const env = {};
+        for (const [key, value] of Object.entries({ ...process.env, ...config.env })) {
+          if (value !== void 0) {
+            env[key] = value;
+          }
+        }
+        transportInstance = new import_stdio.StdioClientTransport({
+          command: config.command,
+          args: config.args,
+          env
+        });
+      } else if (transport === "http" && config.url) {
+        transportInstance = new import_streamableHttp.StreamableHTTPClientTransport(
+          new URL(config.url),
+          {
+            requestInit: {
+              headers: config.headers
+            }
+          }
+        );
+      } else if (transport === "websocket" && config.url) {
+        transportInstance = new import_ws.WebSocket(config.url);
+        await new Promise((resolve, reject) => {
+          transportInstance.on("open", () => resolve());
+          transportInstance.on("error", reject);
+          setTimeout(() => reject(new Error("WebSocket connection timeout")), 1e4);
+        });
+      } else {
+        throw new Error(`Invalid transport configuration for ${name}`);
+      }
+      await client.connect(transportInstance);
+      const toolsResult = await client.request(
+        {
+          method: "tools/list",
+          params: {}
+        },
+        import_types.ListToolsResultSchema
+      );
+      const tools = toolsResult.tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description || "",
+        inputSchema: tool.inputSchema,
+        serverName: name
+      }));
+      const clientInfo = {
+        name,
+        client,
+        transport: transportInstance,
+        transportType: transport,
+        tools,
+        connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastUsed: (/* @__PURE__ */ new Date()).toISOString(),
+        config,
+        status: "connected"
+      };
+      this.clients.set(name, clientInfo);
+      this.log(`\u2705 Connected to ${name} (${tools.length} tools)`);
+      this.printAvailableTools(name, tools);
+      return name;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log(`\u274C Failed to connect to ${name}:`, errorMessage);
+      if (this.options.autoReconnect) {
+        this.scheduleReconnect(name, config);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Disconnect a specific MCP client
+   */
+  async disconnectClient(name) {
+    const client = this.clients.get(name);
+    if (!client) return;
+    const timeout = this.reconnectTimeouts.get(name);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.reconnectTimeouts.delete(name);
+    }
+    try {
+      await client.client.close();
+      if ("close" in client.transport && typeof client.transport.close === "function") {
+        await client.transport.close();
+      }
+    } catch (error) {
+      this.log(`Error closing client ${name}:`, error);
+    }
+    this.clients.delete(name);
+    this.log(`Disconnected from ${name}`);
+  }
+  /**
+   * Schedule a reconnection attempt
+   */
+  scheduleReconnect(name, config) {
+    if (this.reconnectTimeouts.has(name)) return;
+    const timeout = setTimeout(async () => {
+      this.reconnectTimeouts.delete(name);
+      this.log(`Attempting to reconnect to ${name}...`);
+      try {
+        await this.connectClient(config);
+      } catch (error) {
+        this.log(`Reconnection failed for ${name}`);
+      }
+    }, this.options.reconnectDelay);
+    this.reconnectTimeouts.set(name, timeout);
+  }
+  /**
+   * Call a tool on the appropriate MCP client
+   */
+  async callTool(toolName, args, options = {}) {
+    const timeout = options.timeout ?? this.options.toolTimeout;
+    let clientInfo;
+    let actualToolName = toolName;
+    if (options.namespace) {
+      clientInfo = this.clients.get(options.namespace);
+      if (!clientInfo) {
+        throw new Error(`Namespace '${options.namespace}' not found`);
+      }
+      const prefix = `${options.namespace}-`;
+      if (actualToolName.startsWith(prefix)) {
+        actualToolName = actualToolName.slice(prefix.length);
+      }
+      if (!clientInfo.tools.some((t) => t.name === actualToolName)) {
+        throw new Error(`Tool '${actualToolName}' not found in namespace '${options.namespace}'`);
+      }
+    } else {
+      for (const [, info] of this.clients) {
+        const tool = info.tools.find((t) => t.name === toolName);
+        if (tool) {
+          clientInfo = info;
+          break;
+        }
+      }
+    }
+    if (!clientInfo) {
+      throw new Error(`Tool '${toolName}' not found on any connected MCP server`);
+    }
+    const requestId = `req_${++this.requestId}`;
+    clientInfo.lastUsed = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      this.log(`[${requestId}] Calling '${actualToolName}' on '${clientInfo.name}'`);
+      const result = await Promise.race([
+        clientInfo.client.request(
+          {
+            method: "tools/call",
+            params: {
+              name: actualToolName,
+              arguments: args
+            }
+          },
+          import_types.CallToolResultSchema
+        ),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error(`Tool call timeout after ${timeout}ms`)), timeout)
+        )
+      ]);
+      this.log(`[${requestId}] Completed successfully`);
+      return this.formatToolResult(result);
+    } catch (error) {
+      this.log(`[${requestId}] Failed:`, error instanceof Error ? error.message : error);
+      if (error instanceof import_types.McpError) {
+        throw new Error(`MCP Error (${toolName}): ${error.message} (code: ${error.code})`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Format MCP tool result for consistent output
+   */
+  formatToolResult(result) {
+    if (!result || !result.content) {
+      return "";
+    }
+    return result.content.map((item) => {
+      if (item.type === "text") {
+        return item.text || "";
+      } else if (item.type === "resource") {
+        return `[Resource: ${item.resource?.uri || "unknown"}]`;
+      } else if (item.type === "image") {
+        return `[Image: ${item.mimeType || "unknown"}]`;
+      } else if (item.type === "audio") {
+        return `[Audio: ${item.mimeType || "unknown"}]`;
+      } else {
+        return JSON.stringify(item);
+      }
+    }).join("\n");
+  }
+  /**
+   * Get all tools from all connected MCP clients
+   * Optionally with namespace prefix
+   */
+  getAllTools(options = {}) {
+    const allTools = [];
+    for (const [clientName, client] of this.clients) {
+      for (const tool of client.tools) {
+        if (options.namespacePrefix) {
+          allTools.push({
+            ...tool,
+            name: `${clientName}-${tool.name}`
+          });
+        } else {
+          allTools.push(tool);
+        }
+      }
+    }
+    return allTools;
+  }
+  /**
+   * Get tools from a specific client
+   */
+  getClientTools(clientName) {
+    const client = this.clients.get(clientName);
+    return client?.tools || [];
+  }
+  /**
+   * Get list of connected MCP clients
+   */
+  listClients() {
+    return Array.from(this.clients.entries()).map(([name, info]) => ({
+      name,
+      status: info.status,
+      toolCount: info.tools.length,
+      connectedAt: info.connectedAt,
+      lastUsed: info.lastUsed,
+      transportType: info.transportType
+    }));
+  }
+  /**
+   * Get client info by name
+   */
+  getClient(name) {
+    return this.clients.get(name);
+  }
+  /**
+   * Refresh tool lists from all connected clients
+   */
+  async refreshTools() {
+    for (const [name, client] of this.clients) {
+      try {
+        const toolsResult = await client.client.request(
+          {
+            method: "tools/list",
+            params: {}
+          },
+          import_types.ListToolsResultSchema
+        );
+        client.tools = toolsResult.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description || "",
+          inputSchema: tool.inputSchema,
+          serverName: name
+        }));
+        this.log(`Refreshed ${name}: ${client.tools.length} tools`);
+      } catch (error) {
+        this.log(`Failed to refresh tools for ${name}:`, error);
+        client.status = "error";
+        client.error = error instanceof Error ? error.message : String(error);
+      }
+    }
+  }
+  /**
+   * List resources from a specific client or all clients
+   */
+  async listResources(clientName) {
+    const results = [];
+    const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+    for (const name of clients) {
+      const client = this.clients.get(name);
+      if (!client) continue;
+      try {
+        const result = await client.client.request(
+          {
+            method: "resources/list",
+            params: {}
+          },
+          import_types.ListResourcesResultSchema
+        );
+        results.push({
+          clientName: name,
+          resources: result.resources
+        });
+      } catch (error) {
+        this.log(`Failed to list resources for ${name}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Read a resource from a specific client
+   */
+  async readResource(uri, clientName) {
+    if (clientName) {
+      const client = this.clients.get(clientName);
+      if (!client) {
+        throw new Error(`Client '${clientName}' not found`);
+      }
+      const result = await client.client.request(
+        {
+          method: "resources/read",
+          params: { uri }
+        },
+        import_types.ReadResourceResultSchema
+      );
+      return result;
+    } else {
+      for (const [name, client] of this.clients) {
+        try {
+          const result = await client.client.request(
+            {
+              method: "resources/read",
+              params: { uri }
+            },
+            import_types.ReadResourceResultSchema
+          );
+          return { clientName: name, ...result };
+        } catch {
+        }
+      }
+      throw new Error(`Resource '${uri}' not found on any client`);
+    }
+  }
+  /**
+   * List prompts from a specific client or all clients
+   */
+  async listPrompts(clientName) {
+    const results = [];
+    const clients = clientName ? [clientName] : Array.from(this.clients.keys());
+    for (const name of clients) {
+      const client = this.clients.get(name);
+      if (!client) continue;
+      try {
+        const result = await client.client.request(
+          {
+            method: "prompts/list",
+            params: {}
+          },
+          import_types.ListPromptsResultSchema
+        );
+        results.push({
+          clientName: name,
+          prompts: result.prompts
+        });
+      } catch (error) {
+        this.log(`Failed to list prompts for ${name}:`, error);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get a prompt from a specific client
+   */
+  async getPrompt(name, args, clientName) {
+    if (clientName) {
+      const client = this.clients.get(clientName);
+      if (!client) {
+        throw new Error(`Client '${clientName}' not found`);
+      }
+      const result = await client.client.request(
+        {
+          method: "prompts/get",
+          params: { name, arguments: args }
+        },
+        import_types.GetPromptResultSchema
+      );
+      return result;
+    } else {
+      for (const [cName, client] of this.clients) {
+        try {
+          const result = await client.client.request(
+            {
+              method: "prompts/get",
+              params: { name, arguments: args }
+            },
+            import_types.GetPromptResultSchema
+          );
+          return { clientName: cName, ...result };
+        } catch {
+        }
+      }
+      throw new Error(`Prompt '${name}' not found on any client`);
+    }
+  }
+  /**
+   * Health check for all connected clients
+   */
+  async healthCheck() {
+    const results = /* @__PURE__ */ new Map();
+    for (const [name, client] of this.clients) {
+      try {
+        const startTime = Date.now();
+        await client.client.request(
+          {
+            method: "tools/list",
+            params: {}
+          },
+          import_types.ListToolsResultSchema
+        );
+        results.set(name, {
+          status: "healthy",
+          responseTime: Date.now() - startTime
+        });
+      } catch (error) {
+        results.set(name, {
+          status: "unhealthy",
+          responseTime: 0,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        if (this.options.autoReconnect) {
+          this.scheduleReconnect(name, client.config);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Start the automatic refresh timer
+   */
+  startRefreshTimer() {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+    }
+    if (this.options.refreshInterval > 0) {
+      this.refreshTimer = setInterval(async () => {
+        try {
+          await this.refreshTools();
+        } catch (error) {
+          this.log("Auto-refresh failed:", error);
+        }
+      }, this.options.refreshInterval);
+    }
+  }
+  /**
+   * Print available tools for a client
+   */
+  printAvailableTools(clientName, tools) {
+    if (tools.length === 0) {
+      this.log(`  No tools available from ${clientName}`);
+      return;
+    }
+    this.log(`
+  --- ${clientName} Tools (${tools.length}) ---`);
+    for (const tool of tools) {
+      this.log(`    \u2022 ${tool.name}: ${tool.description.slice(0, 60)}${tool.description.length > 60 ? "..." : ""}`);
+    }
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.options.debug) {
+      console.log("[MCP-Proxy]", ...args);
+    }
+  }
+  /**
+   * Get statistics about the MCP proxy hub
+   */
+  getStats() {
+    const clients = Array.from(this.clients.entries()).map(([name, info]) => ({
+      name,
+      toolCount: info.tools.length,
+      status: info.status,
+      transportType: info.transportType
+    }));
+    return {
+      totalClients: this.clients.size,
+      totalTools: clients.reduce((sum, c) => sum + c.toolCount, 0),
+      clients
+    };
+  }
+};
+
 // src/daemon/index.ts
 var RainfallDaemon = class {
   wss;
@@ -1661,11 +2227,16 @@ var RainfallDaemon = class {
   networkedExecutor;
   context;
   listeners;
+  mcpProxy;
+  enableMcpProxy;
+  mcpNamespacePrefix;
   constructor(config = {}) {
     this.port = config.port || 8765;
     this.openaiPort = config.openaiPort || 8787;
     this.rainfallConfig = config.rainfallConfig;
     this.debug = config.debug || false;
+    this.enableMcpProxy = config.enableMcpProxy ?? true;
+    this.mcpNamespacePrefix = config.mcpNamespacePrefix ?? true;
     this.openaiApp = (0, import_express.default)();
     this.openaiApp.use(import_express.default.json());
   }
@@ -1701,6 +2272,19 @@ var RainfallDaemon = class {
       this.networkedExecutor
     );
     await this.loadTools();
+    if (this.enableMcpProxy) {
+      this.mcpProxy = new MCPProxyHub({ debug: this.debug });
+      await this.mcpProxy.initialize();
+      if (this.rainfallConfig?.mcpClients) {
+        for (const clientConfig of this.rainfallConfig.mcpClients) {
+          try {
+            await this.mcpProxy.connectClient(clientConfig);
+          } catch (error) {
+            this.log(`Failed to connect MCP client ${clientConfig.name}:`, error);
+          }
+        }
+      }
+    }
     await this.startWebSocketServer();
     await this.startOpenAIProxy();
     console.log(`\u{1F680} Rainfall daemon running`);
@@ -1721,6 +2305,10 @@ var RainfallDaemon = class {
     if (this.networkedExecutor) {
       await this.networkedExecutor.unregisterEdgeNode();
     }
+    if (this.mcpProxy) {
+      await this.mcpProxy.shutdown();
+      this.mcpProxy = void 0;
+    }
     for (const client of this.clients) {
       client.close();
     }
@@ -1749,6 +2337,30 @@ var RainfallDaemon = class {
   getListenerRegistry() {
     return this.listeners;
   }
+  /**
+   * Get the MCP Proxy Hub for managing external MCP clients
+   */
+  getMCPProxy() {
+    return this.mcpProxy;
+  }
+  /**
+   * Connect an MCP client dynamically
+   */
+  async connectMCPClient(config) {
+    if (!this.mcpProxy) {
+      throw new Error("MCP Proxy Hub is not enabled");
+    }
+    return this.mcpProxy.connectClient(config);
+  }
+  /**
+   * Disconnect an MCP client
+   */
+  async disconnectMCPClient(name) {
+    if (!this.mcpProxy) {
+      throw new Error("MCP Proxy Hub is not enabled");
+    }
+    return this.mcpProxy.disconnectClient(name);
+  }
   async initializeRainfall() {
     if (this.rainfallConfig?.apiKey) {
       this.rainfall = new Rainfall(this.rainfallConfig);
@@ -1789,7 +2401,7 @@ var RainfallDaemon = class {
     }
   }
   async startWebSocketServer() {
-    this.wss = new import_ws.WebSocketServer({ port: this.port });
+    this.wss = new import_ws2.WebSocketServer({ port: this.port });
     this.wss.on("connection", (ws) => {
       this.log("\u{1F7E2} MCP client connected");
       this.clients.add(ws);
@@ -1851,7 +2463,7 @@ var RainfallDaemon = class {
         const toolParams = params?.arguments;
         try {
           const startTime = Date.now();
-          const result = await this.executeTool(toolName, toolParams);
+          const result = await this.executeToolWithMCP(toolName, toolParams);
           const duration = Date.now() - startTime;
           if (this.context) {
             this.context.recordExecution(toolName, toolParams || {}, result, { duration });
@@ -1916,6 +2528,16 @@ var RainfallDaemon = class {
         });
       }
     }
+    if (this.mcpProxy) {
+      const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+      for (const tool of proxyTools) {
+        mcpTools.push({
+          name: this.mcpNamespacePrefix ? `${tool.serverName}-${tool.name}` : tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema || { type: "object", properties: {} }
+        });
+      }
+    }
     return mcpTools;
   }
   async executeTool(toolId, params) {
@@ -1924,6 +2546,30 @@ var RainfallDaemon = class {
     }
     return this.rainfall.executeTool(toolId, params);
   }
+  /**
+   * Execute a tool, trying MCP proxy first, then falling back to Rainfall tools
+   */
+  async executeToolWithMCP(toolName, params) {
+    if (this.mcpProxy) {
+      try {
+        if (this.mcpNamespacePrefix && toolName.includes("-")) {
+          const namespace = toolName.split("-")[0];
+          const actualToolName = toolName.slice(namespace.length + 1);
+          if (this.mcpProxy.getClient(namespace)) {
+            return await this.mcpProxy.callTool(toolName, params || {}, {
+              namespace
+            });
+          }
+        }
+        return await this.mcpProxy.callTool(toolName, params || {});
+      } catch (error) {
+        if (error instanceof Error && !error.message.includes("not found")) {
+          throw error;
+        }
+      }
+    }
+    return this.executeTool(toolName, params);
+  }
   async startOpenAIProxy() {
     this.openaiApp.get("/v1/models", async (_req, res) => {
       try {
@@ -2039,6 +2685,10 @@ var RainfallDaemon = class {
                 this.log(`  \u2192 Executing locally`);
                 const args = JSON.parse(toolArgsStr);
                 toolResult = await this.executeLocalTool(localTool.id, args);
+              } else if (this.mcpProxy) {
+                this.log(`  \u2192 Trying MCP proxy`);
+                const args = JSON.parse(toolArgsStr);
+                toolResult = await this.executeToolWithMCP(toolName.replace(/_/g, "-"), args);
               } else {
                 const shouldExecuteLocal = body.tool_priority === "local" || body.tool_priority === "stacked";
                 if (shouldExecuteLocal) {
@@ -2088,15 +2738,52 @@ var RainfallDaemon = class {
       }
     });
     this.openaiApp.get("/health", (_req, res) => {
+      const mcpStats = this.mcpProxy?.getStats();
       res.json({
         status: "ok",
         daemon: "rainfall",
-        version: "0.1.0",
+        version: "0.2.0",
         tools_loaded: this.tools.length,
+        mcp_clients: mcpStats?.totalClients || 0,
+        mcp_tools: mcpStats?.totalTools || 0,
         edge_node_id: this.networkedExecutor?.getEdgeNodeId(),
         clients_connected: this.clients.size
       });
     });
+    this.openaiApp.get("/v1/mcp/clients", (_req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      res.json(this.mcpProxy.listClients());
+    });
+    this.openaiApp.post("/v1/mcp/connect", async (req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      try {
+        const name = await this.mcpProxy.connectClient(req.body);
+        res.json({ success: true, client: name });
+      } catch (error) {
+        res.status(500).json({
+          error: error instanceof Error ? error.message : "Failed to connect MCP client"
+        });
+      }
+    });
+    this.openaiApp.post("/v1/mcp/disconnect", async (req, res) => {
+      if (!this.mcpProxy) {
+        res.status(503).json({ error: "MCP proxy not enabled" });
+        return;
+      }
+      const { name } = req.body;
+      if (!name) {
+        res.status(400).json({ error: "Missing required field: name" });
+        return;
+      }
+      await this.mcpProxy.disconnectClient(name);
+      res.json({ success: true });
+    });
     this.openaiApp.get("/status", (_req, res) => {
       res.json(this.getStatus());
     });
@@ -2231,6 +2918,7 @@ var RainfallDaemon = class {
     switch (provider) {
       case "local":
       case "ollama":
+      case "custom":
         return this.callLocalLLM(params, config);
       case "openai":
       case "anthropic":
@@ -2267,7 +2955,8 @@ var RainfallDaemon = class {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
+        "Authorization": `Bearer ${apiKey}`,
+        "User-Agent": "Rainfall-DevKit/1.0"
       },
       body: JSON.stringify({
         model,
@@ -2298,7 +2987,8 @@ var RainfallDaemon = class {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
+        "Authorization": `Bearer ${apiKey}`,
+        "User-Agent": "Rainfall-DevKit/1.0"
       },
       body: JSON.stringify({
         model,
@@ -2379,7 +3069,7 @@ var RainfallDaemon = class {
   }
   async getOpenAITools() {
     const tools = [];
-    for (const tool of this.tools.slice(0, 128)) {
+    for (const tool of this.tools.slice(0, 100)) {
       const schema = await this.getToolSchema(tool.id);
       if (schema) {
         const toolSchema = schema;
@@ -2403,6 +3093,24 @@ var RainfallDaemon = class {
         });
       }
     }
+    if (this.mcpProxy) {
+      const proxyTools = this.mcpProxy.getAllTools({ namespacePrefix: this.mcpNamespacePrefix });
+      for (const tool of proxyTools.slice(0, 28)) {
+        const inputSchema = tool.inputSchema || {};
+        tools.push({
+          type: "function",
+          function: {
+            name: this.mcpNamespacePrefix ? `${tool.serverName}_${tool.name}`.replace(/-/g, "_") : tool.name.replace(/-/g, "_"),
+            description: `[${tool.serverName}] ${tool.description}`,
+            parameters: {
+              type: "object",
+              properties: inputSchema.properties || {},
+              required: inputSchema.required || []
+            }
+          }
+        });
+      }
+    }
     return tools;
   }
   buildResponseContent() {
@@ -2465,6 +3173,7 @@ function getDaemonInstance() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MCPProxyHub,
   RainfallDaemon,
   getDaemonInstance,
   getDaemonStatus,