kiku-agent 1.0.11 → 1.2.0

package/server/agent/mcpClient.js

@@ -7,6 +7,26 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { KIKU_DATA_DIR } from './appPaths.js';
 
+function getPredefinedKikuMcpTools() {
+  return [
+    { name: 'search_works', description: 'Search drama and film works by year, title, or role', inputSchema: { type: 'object', properties: { query: { type: 'string' }, year: { type: 'number' } } } },
+    { name: 'get_work_detail', description: 'Get detailed information about a specific drama or film', inputSchema: { type: 'object', properties: { title: { type: 'string' } }, required: ['title'] } },
+    { name: 'get_character_roles', description: 'Explore character roles played by Ju Jingyi', inputSchema: { type: 'object', properties: { role: { type: 'string' } } } },
+    { name: 'search_discography', description: 'Search singles, albums, OSTs, and songs', inputSchema: { type: 'object', properties: { query: { type: 'string' }, type: { type: 'string' } } } },
+    { name: 'get_music_videos', description: 'Find official music videos, dance practices, and live stages', inputSchema: { type: 'object', properties: { query: { type: 'string' } } } },
+    { name: 'get_media_links', description: 'Get streaming and watch links across YouTube, Bilibili, and QQ Music', inputSchema: { type: 'object', properties: { title: { type: 'string' } } } },
+    { name: 'get_brand_endorsements', description: 'Look up global brand ambassadorships and fashion partnerships', inputSchema: { type: 'object', properties: { brand: { type: 'string' }, tier: { type: 'string' } } } },
+    { name: 'get_career_timeline', description: 'Explore milestones from SNH48 debut to solo career', inputSchema: { type: 'object', properties: { era: { type: 'string' }, year: { type: 'number' } } } },
+    { name: 'get_awards', description: 'Look up music awards, acting honors, and Weibo Night recognitions', inputSchema: { type: 'object', properties: { query: { type: 'string' }, year: { type: 'number' } } } },
+    { name: 'get_profile_and_fandom', description: 'Get biographical details, fandom facts, and official links', inputSchema: { type: 'object', properties: { topic: { type: 'string' } } } },
+    { name: 'get_quotes', description: 'Get famous quotes and inspirational sayings', inputSchema: { type: 'object', properties: { topic: { type: 'string' } } } },
+    { name: 'get_social_feed', description: 'Fetch official social media posts and updates', inputSchema: { type: 'object', properties: { platform: { type: 'string' }, limit: { type: 'number' } } } },
+    { name: 'get_gallery_photos', description: 'Search gallery photoshoot pictures and posters', inputSchema: { type: 'object', properties: { query: { type: 'string' }, tag: { type: 'string' } } } },
+    { name: 'global_search', description: 'Universal search across dramas, songs, brands, and awards', inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] } },
+    { name: 'get_system_stats', description: 'View knowledge base statistics and metrics', inputSchema: { type: 'object', properties: {} } },
+  ];
+}
+
 export class McpClientManager {
   constructor(options = {}) {
     this.clientInfo = options.clientInfo || { name: 'kiku-agent', version: PACKAGE_VERSION };
@@ -22,6 +42,40 @@ export class McpClientManager {
     this.persistedConfigs = new Map();
     this.configSources = new Map();
     this.toolRegistry = new Map();
+    this.cooldowns = new Map();
+  }
+
+  _isRateLimited(serverName) {
+    const cd = this.cooldowns.get(serverName);
+    if (!cd) return false;
+    if (Date.now() < cd.until) return true;
+    this.cooldowns.delete(serverName);
+    return false;
+  }
+
+  _registerRateLimit(serverName, errorMessage, { logWarning = false } = {}) {
+    const is429 = String(errorMessage).includes('429') || 
+                  /rate limit|too many requests/i.test(String(errorMessage));
+    if (!is429) return false;
+
+    let retrySec = 45;
+    try {
+      const match = String(errorMessage).match(/"retryAfterSeconds"\s*:\s*(\d+)/i) || 
+                    String(errorMessage).match(/(\d+)\s*seconds?/i);
+      if (match && match[1]) retrySec = Math.min(Math.max(parseInt(match[1], 10), 10), 300);
+    } catch {}
+
+    const existing = this.cooldowns.get(serverName);
+    const now = Date.now();
+    const until = now + retrySec * 1000;
+
+    if (!existing || now >= existing.until) {
+      this.cooldowns.set(serverName, { until, warned: true, error: errorMessage });
+      if (logWarning) {
+        console.warn(`[MCP] Notice: Server "${serverName}" hit rate limit (429). Cooldown for ${retrySec}s — requests paused to avoid spam.`);
+      }
+    }
+    return true;
   }
 
   _trackConfigSource(serverName, filePath) {
@@ -58,12 +112,30 @@ export class McpClientManager {
     return changed;
   }
 
-  async connect(serverName, serverConfig = {}, { persist = true } = {}) {
+  async _ensureConnected(serverName) {
+    const entry = this.servers.get(serverName);
+    if (entry && entry.client && !entry.isLazy) {
+      return entry;
+    }
+    const cfg = this.persistedConfigs.get(serverName);
+    if (!cfg) {
+      throw new Error(`MCP server "${serverName}" configuration not found.`);
+    }
+    await this.connect(serverName, cfg, { persist: false, fetchMetadata: false });
+    return this.servers.get(serverName);
+  }
+
+  async connect(serverName, serverConfig = {}, { persist = true, fetchMetadata = false } = {}) {
     const name = String(serverName || '').trim();
     if (!name) throw new Error('Server name is required to connect to MCP.');
 
     if (this.servers.has(name)) {
-      await this.disconnect(name, { persist: false });
+      const existing = this.servers.get(name);
+      if (existing.client) {
+        await this.disconnect(name, { persist: false });
+      } else {
+        this.servers.delete(name);
+      }
     }
 
     let transport;
@@ -109,28 +181,39 @@ export class McpClientManager {
     try {
       await client.connect(transport);
 
-      let tools = [];
-      let resources = [];
-      let prompts = [];
+      let tools = serverConfig.tools || [];
+      let resources = serverConfig.resources || [];
+      let prompts = serverConfig.prompts || [];
 
-      try {
-        const toolsResult = await client.listTools();
-        tools = toolsResult.tools || [];
-      } catch (err) {
-        console.warn(`[MCP] Failed to list tools from ${name}: ${err.message}`);
+      // If tools not pre-provided, fetch once upon connection
+      if (!tools || tools.length === 0) {
+        try {
+          if (!this._isRateLimited(name)) {
+            const toolsResult = await client.listTools();
+            tools = toolsResult.tools || [];
+          }
+        } catch (err) {
+          this._registerRateLimit(name, err.message, { logWarning: false });
+        }
       }
 
-      try {
-        const resResult = await client.listResources();
-        resources = resResult.resources || [];
-      } catch {}
+      if (fetchMetadata) {
+        try {
+          if (!this._isRateLimited(name)) {
+            const resResult = await client.listResources();
+            resources = resResult.resources || [];
+          }
+        } catch {}
 
-      try {
-        const promptResult = await client.listPrompts();
-        prompts = promptResult.prompts || [];
-      } catch {}
+        try {
+          if (!this._isRateLimited(name)) {
+            const promptResult = await client.listPrompts();
+            prompts = promptResult.prompts || [];
+          }
+        } catch {}
+      }
 
-      const cleanConfig = { ...serverConfig, enabled: true };
+      const cleanConfig = { ...serverConfig, enabled: true, tools };
       delete cleanConfig.lastError;
 
       const serverEntry = {
@@ -142,6 +225,7 @@ export class McpClientManager {
         resources,
         prompts,
         connectedAt: new Date().toISOString(),
+        isLazy: false,
       };
 
       this.servers.set(name, serverEntry);
@@ -173,8 +257,8 @@ export class McpClientManager {
     if (!entry) return false;
 
     try {
-      await entry.client.close().catch(() => {});
-      await entry.transport.close().catch(() => {});
+      if (entry.client) await entry.client.close().catch(() => {});
+      if (entry.transport) await entry.transport.close().catch(() => {});
       if (entry.transport?._process) {
         try {
           entry.transport._process.kill('SIGKILL');
@@ -310,8 +394,33 @@ export class McpClientManager {
       };
     }
 
-    const serverEntry = this.servers.get(registration.serverName);
-    if (!serverEntry) {
+    if (this._isRateLimited(registration.serverName)) {
+      const cd = this.cooldowns.get(registration.serverName);
+      const remainingSec = Math.max(1, Math.ceil((cd.until - Date.now()) / 1000));
+      return {
+        status: 'rate_limited',
+        server: registration.serverName,
+        tool: registration.originalName,
+        message: `MCP server "${registration.serverName}" is currently in rate-limit cooldown (${remainingSec}s remaining). Requests are paused to prevent rate limiting.`,
+      };
+    }
+
+    let serverEntry = this.servers.get(registration.serverName);
+    if (!serverEntry || !serverEntry.client || serverEntry.isLazy) {
+      try {
+        serverEntry = await this._ensureConnected(registration.serverName);
+      } catch (connErr) {
+        this._registerRateLimit(registration.serverName, connErr.message, { logWarning: false });
+        return {
+          status: 'error',
+          server: registration.serverName,
+          tool: registration.originalName,
+          message: `Could not connect to MCP server "${registration.serverName}": ${connErr.message}`,
+        };
+      }
+    }
+
+    if (!serverEntry || !serverEntry.client) {
       return {
         status: 'error',
         message: `MCP server "${registration.serverName}" is disconnected.`,
@@ -358,6 +467,7 @@ export class McpClientManager {
         _rawMcp: response.content,
       };
     } catch (err) {
+      this._registerRateLimit(registration.serverName, err.message, { logWarning: false });
       return {
         status: 'error',
         server: registration.serverName,
@@ -373,14 +483,18 @@ export class McpClientManager {
 
     for (const [name, server] of this.servers.entries()) {
       seen.add(name);
+      const isRateLimited = this._isRateLimited(name);
+      const cd = this.cooldowns.get(name);
       list.push({
         name,
-        status: 'connected',
-        type: server.config.type || (server.config.command ? 'stdio' : 'streamable-http'),
-        toolsCount: server.tools.length,
-        resourcesCount: server.resources.length,
-        promptsCount: server.prompts.length,
+        status: isRateLimited ? 'rate_limited' : 'connected',
+        type: server.config?.type || (server.config?.command ? 'stdio' : 'streamable-http'),
+        toolsCount: server.tools?.length || 0,
+        resourcesCount: server.resources?.length || 0,
+        promptsCount: server.prompts?.length || 0,
         connectedAt: server.connectedAt,
+        isLazy: Boolean(server.isLazy),
+        cooldownRemainingSec: isRateLimited ? Math.max(1, Math.ceil((cd.until - Date.now()) / 1000)) : null,
         sources: [...(this.configSources.get(name) || [])],
         config: server.config,
       });
@@ -392,9 +506,9 @@ export class McpClientManager {
         name,
         status: cfg.lastError ? 'error' : (cfg.enabled === false ? 'disabled' : 'saved_offline'),
         type: cfg.type || (cfg.command ? 'stdio' : 'streamable-http'),
-        toolsCount: 0,
-        resourcesCount: 0,
-        promptsCount: 0,
+        toolsCount: (cfg.tools || []).length,
+        resourcesCount: (cfg.resources || []).length,
+        promptsCount: (cfg.prompts || []).length,
         error: cfg.lastError || null,
         sources: [...(this.configSources.get(name) || [])],
         config: cfg,
@@ -455,8 +569,44 @@ export class McpClientManager {
           this._trackConfigSource(name, filePath);
           if (cfg.enabled === false || cfg.disabled === true) continue;
           if (this.servers.has(name)) continue;
+
+          // If tools are cached or it's a known Kiku remote MCP server, register lazily without network call on startup
+          let tools = cfg.tools;
+          if (!tools || tools.length === 0) {
+            if (name === 'kiku-mcp' || /jujingyi-kikuuu|vercel\.app/i.test(cfg.url || '')) {
+              tools = getPredefinedKikuMcpTools();
+              cfg.tools = tools;
+            }
+          }
+
+          if (tools && Array.isArray(tools) && tools.length > 0) {
+            const serverEntry = {
+              name,
+              config: cfg,
+              client: null,
+              transport: null,
+              tools,
+              resources: cfg.resources || [],
+              prompts: cfg.prompts || [],
+              connectedAt: new Date().toISOString(),
+              isLazy: true,
+            };
+            this.servers.set(name, serverEntry);
+            this._rebuildToolRegistry();
+            results.push({
+              success: true,
+              serverName: name,
+              toolsCount: tools.length,
+              resourcesCount: (cfg.resources || []).length,
+              promptsCount: (cfg.prompts || []).length,
+              tools,
+              lazy: true,
+            });
+            continue;
+          }
+
           try {
-            const res = await this.connect(name, cfg, { persist: false });
+            const res = await this.connect(name, cfg, { persist: false, fetchMetadata: false });
             results.push(res);
           } catch (err) {
             results.push({ success: false, serverName: name, error: err.message });