ydc-mcp-server 1.6.1

package/index.js

@@ -0,0 +1,604 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+import { randomUUID } from 'crypto';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Import shared modules
+import { AGENT_TYPES, callYouApi, extractText, buildConversationInput, buildAgentRequest } from './lib/api-client.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// ============ CLI MODE CHECK ============
+const args = process.argv.slice(2);
+
+// Parse CLI arguments
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--api-key' && args[i + 1]) {
+    process.env.YDC_API_KEY = args[i + 1];
+  }
+  if (args[i] === '--api-keys' && args[i + 1]) {
+    process.env.YDC_API_KEYS = args[i + 1];
+  }
+  if ((args[i] === '--port' || args[i] === '-p') && args[i + 1]) {
+    process.env.YDC_OPENAI_PORT = args[i + 1];
+  }
+  if (args[i] === '--access-token' && args[i + 1]) {
+    process.env.YDC_OPENAI_ACCESS_TOKENS = args[i + 1];
+  }
+  if (args[i] === '--key-mode' && args[i + 1]) {
+    process.env.YDC_KEY_MODE = args[i + 1];
+  }
+  if (args[i] === '--agent' && args[i + 1]) {
+    // Format: name:id or just id (name defaults to id)
+    const existing = process.env.YDC_CUSTOM_AGENTS || '';
+    process.env.YDC_CUSTOM_AGENTS = existing ? `${existing},${args[i + 1]}` : args[i + 1];
+  }
+}
+
+const isOpenAIMode = args.includes('--openai') || args.includes('openai');
+
+if (isOpenAIMode) {
+  // Start OpenAI-compatible HTTP server using spawn
+  const openaiServerPath = join(__dirname, 'openai-server.js');
+  const child = spawn('node', [openaiServerPath], { 
+    stdio: 'inherit',
+    env: process.env
+  });
+  child.on('exit', (code) => process.exit(code));
+} else if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+ydc-mcp-server - MCP server for You.com AI agents
+
+Usage:
+  npx ydc-mcp-server                              Start MCP server (stdio)
+  npx ydc-mcp-server --openai                     Start OpenAI-compatible HTTP server
+  npx ydc-mcp-server --openai --api-key KEY       Start with single API key
+  npx ydc-mcp-server --openai --api-keys K1,K2    Start with multiple API keys
+  npx ydc-mcp-server --openai --port 3003         Start on custom port
+  npx ydc-mcp-server --openai --access-token TOK  Require access token for HTTP server
+
+Options:
+  --openai              Start OpenAI-compatible HTTP server
+  --api-key KEY         Set single You.com API key
+  --api-keys K1,K2,K3   Set multiple API keys (comma-separated)
+  --key-mode MODE       Key rotation: round-robin (default) / sequential / random
+  --port, -p PORT       Set HTTP server port (default: 3002)
+  --access-token TOKEN  Set access token for HTTP server authentication
+  --agent NAME:ID       Add custom agent to models list (can use multiple times)
+  --help, -h            Show this help
+
+Environment Variables:
+  YDC_API_KEY                You.com API key (required)
+  YDC_API_KEYS               Multiple keys (comma-separated)
+  YDC_KEY_MODE               round-robin / sequential / random
+  YDC_OPENAI_PORT            HTTP server port (default: 3002)
+  YDC_CONVERSATION_STORE     sqlite / memory (default: sqlite)
+  YDC_OPENAI_ACCESS_TOKENS   Allowed tokens (comma-separated)
+  YDC_CUSTOM_AGENTS          Custom agents (name:id,name2:id2)
+`);
+  process.exit(0);
+}
+
+// Skip MCP server if in OpenAI mode
+if (isOpenAIMode) {
+  // Wait forever, child process handles everything
+  setInterval(() => {}, 1000000);
+} else {
+
+// ============ OPENAI SERVER CONTROL ============
+let openaiServerProcess = null;
+let openaiServerPort = null;
+let openaiServerStatus = 'stopped';
+
+// ============ MULTI-KEY CONFIGURATION ============
+const API_KEYS_RAW = process.env.YDC_API_KEYS || process.env.YDC_API_KEY || '';
+const API_KEYS = API_KEYS_RAW.split(',').map(k => k.trim()).filter(k => k);
+const KEY_MODE = process.env.YDC_KEY_MODE || 'round-robin';
+let currentKeyIndex = 0;
+const keyUsageCount = new Map();
+const keyErrorCount = new Map();
+
+// ============ OPENAI SERVER ENV PASSTHROUGH ============
+const OPENAI_SERVER_STORE_TYPE = process.env.YDC_CONVERSATION_STORE || 'sqlite';
+const OPENAI_SERVER_DB_PATH = process.env.YDC_CONVERSATION_DB_PATH || '';
+const OPENAI_SERVER_ACCESS_TOKENS = process.env.YDC_OPENAI_ACCESS_TOKENS || '';
+
+// ============ CONVERSATION STORE (Memory for MCP) ============
+const conversationStore = new Map();
+const CONVERSATION_TTL = 24 * 60 * 60 * 1000;
+const MAX_MESSAGES_PER_CONVERSATION = 100;
+
+function generateConversationId() {
+  return randomUUID();
+}
+
+function getConversation(conversationId) {
+  if (!conversationId || !conversationStore.has(conversationId)) return null;
+  const conv = conversationStore.get(conversationId);
+  conv.updatedAt = Date.now();
+  return conv;
+}
+
+function createConversation(conversationId = null) {
+  const id = conversationId || generateConversationId();
+  const conv = { id, messages: [], createdAt: Date.now(), updatedAt: Date.now() };
+  conversationStore.set(id, conv);
+  return conv;
+}
+
+function addMessageToConversation(conversationId, role, content) {
+  let conv = getConversation(conversationId);
+  if (!conv) conv = createConversation(conversationId);
+  
+  if (conv.messages.length >= MAX_MESSAGES_PER_CONVERSATION) {
+    const systemMsg = conv.messages.find(m => m.role === 'system');
+    conv.messages = systemMsg 
+      ? [systemMsg, ...conv.messages.slice(-MAX_MESSAGES_PER_CONVERSATION + 2)] 
+      : conv.messages.slice(-MAX_MESSAGES_PER_CONVERSATION + 1);
+  }
+  
+  conv.messages.push({ role, content, timestamp: Date.now() });
+  conv.updatedAt = Date.now();
+  return conv;
+}
+
+// Cleanup expired conversations
+setInterval(() => {
+  const now = Date.now();
+  for (const [id, conv] of conversationStore.entries()) {
+    if (now - conv.updatedAt > CONVERSATION_TTL) conversationStore.delete(id);
+  }
+}, 60 * 60 * 1000);
+
+// ============ API KEY MANAGEMENT ============
+function isRunningAsNpx() {
+  const execPath = process.argv[1] || '';
+  return execPath.includes('node_modules') || execPath.includes('.npm/_npx') || 
+         execPath.includes('npx') || execPath.includes('pnpm/global');
+}
+
+function validateApiKeys() {
+  if (API_KEYS.length === 0) {
+    console.error('ERROR: No API keys configured!');
+    console.error('Please set YDC_API_KEY or YDC_API_KEYS environment variable in mcp.json');
+    
+    const config = isRunningAsNpx() 
+      ? { command: "npx", args: ["-y", "ydc-mcp-server"] }
+      : { command: "node", args: [process.argv[1] || "path/to/index.js"] };
+    
+    console.error('\nExample mcp.json config:');
+    console.error(JSON.stringify({
+      mcpServers: {
+        "ydc-mcp-server": {
+          ...config,
+          env: { YDC_API_KEY: "your-api-key-here", YDC_KEY_MODE: "round-robin" }
+        }
+      }
+    }, null, 2));
+    return false;
+  }
+  return true;
+}
+
+function getNextApiKey() {
+  if (API_KEYS.length === 0) throw new Error('No API keys configured');
+  
+  let key;
+  if (API_KEYS.length === 1) {
+    key = API_KEYS[0];
+  } else {
+    switch (KEY_MODE) {
+      case 'sequential': key = API_KEYS[currentKeyIndex]; break;
+      case 'random': key = API_KEYS[Math.floor(Math.random() * API_KEYS.length)]; break;
+      default: // round-robin
+        key = API_KEYS[currentKeyIndex];
+        currentKeyIndex = (currentKeyIndex + 1) % API_KEYS.length;
+    }
+  }
+  
+  keyUsageCount.set(key, (keyUsageCount.get(key) || 0) + 1);
+  return key;
+}
+
+function markKeyError(key) {
+  keyErrorCount.set(key, (keyErrorCount.get(key) || 0) + 1);
+  if (KEY_MODE === 'sequential') currentKeyIndex = (currentKeyIndex + 1) % API_KEYS.length;
+}
+
+// ============ MCP SERVER ============
+class YouAgentsServer {
+  constructor() {
+    this.server = new Server(
+      { name: 'ydc-mcp-server', version: '1.5.1' },
+      { capabilities: { tools: {} } }
+    );
+    this.setupToolHandlers();
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => { await this.server.close(); process.exit(0); });
+  }
+
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'you_search',
+          description: 'Web and news search via You.com',
+          inputSchema: {
+            type: 'object',
+            properties: { query: { type: 'string', description: 'Search query' } },
+            required: ['query'],
+          },
+        },
+        {
+          name: 'you_express',
+          description: 'Fast AI answers with web search',
+          inputSchema: {
+            type: 'object',
+            properties: { input: { type: 'string', description: 'Query or prompt' } },
+            required: ['input'],
+          },
+        },
+        {
+          name: 'you_advanced',
+          description: 'Advanced AI agent for complex reasoning and research',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              input: { type: 'string', description: 'Query or prompt' },
+              conversation_id: { type: 'string', description: 'Optional conversation ID for multi-turn dialogue' },
+              agent_type: { 
+                type: 'string', 
+                enum: Object.keys(AGENT_TYPES),
+                default: 'advanced-3.0-high'
+              },
+              verbosity: { type: 'string', enum: ['medium', 'high'], default: 'high' },
+              max_workflow_steps: { type: 'number', default: 15, minimum: 1, maximum: 20 },
+            },
+            required: ['input'],
+          },
+        },
+        {
+          name: 'you_chat',
+          description: 'OpenAI-compatible chat interface with conversation history',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              messages: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: {
+                    role: { type: 'string', enum: ['system', 'user', 'assistant'] },
+                    content: { type: 'string' }
+                  },
+                  required: ['role', 'content']
+                }
+              },
+              conversation_id: { type: 'string' },
+              model: { 
+                type: 'string', 
+                enum: Object.keys(AGENT_TYPES),
+                default: 'advanced-3.0-high' 
+              },
+            },
+            required: ['messages'],
+          },
+        },
+        {
+          name: 'you_conversation_list',
+          description: 'List all active conversations',
+          inputSchema: { type: 'object', properties: {} },
+        },
+        {
+          name: 'you_conversation_get',
+          description: 'Get conversation history by ID',
+          inputSchema: {
+            type: 'object',
+            properties: { conversation_id: { type: 'string' } },
+            required: ['conversation_id'],
+          },
+        },
+        {
+          name: 'you_conversation_delete',
+          description: 'Delete a conversation',
+          inputSchema: {
+            type: 'object',
+            properties: { conversation_id: { type: 'string' } },
+            required: ['conversation_id'],
+          },
+        },
+        {
+          name: 'you_key_status',
+          description: 'Get API key usage status',
+          inputSchema: { type: 'object', properties: {} },
+        },
+        {
+          name: 'openai_server_control',
+          description: 'Control the OpenAI-compatible HTTP server (start/stop/restart/status)',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              action: { type: 'string', enum: ['start', 'stop', 'restart', 'status'] },
+              port: { type: 'number', default: 3002 },
+              access_tokens: { type: 'array', items: { type: 'string' } },
+              store_type: { type: 'string', enum: ['sqlite', 'memory'], default: 'sqlite' },
+              db_path: { type: 'string' },
+            },
+            required: ['action'],
+          },
+        },
+      ],
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        switch (name) {
+          case 'you_search': return await this.callExpress(args.query);
+          case 'you_express': return await this.callExpress(args.input);
+          case 'you_advanced': return await this.callAdvanced(args);
+          case 'you_chat': return await this.callChat(args);
+          case 'you_conversation_list': return this.listConversations();
+          case 'you_conversation_get': return this.getConversationHistory(args.conversation_id);
+          case 'you_conversation_delete': return this.deleteConversation(args.conversation_id);
+          case 'you_key_status': return this.getKeyStatus();
+          case 'openai_server_control': return await this.controlOpenAIServer(args);
+          default: throw new Error(`Unknown tool: ${name}`);
+        }
+      } catch (error) {
+        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+      }
+    });
+  }
+
+  async callExpress(input) {
+    const apiKey = getNextApiKey();
+    try {
+      const response = await callYouApi(apiKey, { agent: 'express', input, stream: false });
+      const data = await response.json();
+      return { content: [{ type: 'text', text: extractText(data) }] };
+    } catch (error) {
+      markKeyError(apiKey);
+      throw error;
+    }
+  }
+
+  async callAdvanced(args) {
+    const { input, conversation_id, agent_type = 'advanced-3.0-high', verbosity, max_workflow_steps } = args;
+    const apiKey = getNextApiKey();
+    let conversationId = conversation_id || generateConversationId();
+    let fullInput = input;
+
+    const conv = getConversation(conversationId);
+    if (conv && conv.messages.length > 0) {
+      const history = conv.messages.map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`).join('\n\n');
+      fullInput = `[Conversation History]\n${history}\n\n[Current Message]\n${input}`;
+    }
+
+    addMessageToConversation(conversationId, 'user', input);
+    const requestBody = buildAgentRequest(agent_type, fullInput, { verbosity, max_workflow_steps });
+
+    try {
+      const response = await callYouApi(apiKey, requestBody);
+      const data = await response.json();
+      const resultText = extractText(data);
+      addMessageToConversation(conversationId, 'assistant', resultText);
+
+      return {
+        content: [
+          { type: 'text', text: resultText },
+          { type: 'text', text: `\n\n---\nConversation ID: ${conversationId}\nAgent: ${agent_type}` }
+        ],
+      };
+    } catch (error) {
+      markKeyError(apiKey);
+      throw error;
+    }
+  }
+
+  async callChat(args) {
+    const { messages, conversation_id, model = 'advanced-3.0-high' } = args;
+    const apiKey = getNextApiKey();
+    let conversationId = conversation_id || generateConversationId();
+    let fullMessages = [...messages];
+
+    const conv = getConversation(conversationId);
+    if (conv && conv.messages.length > 0) {
+      const storedMessages = conv.messages.map(m => ({ role: m.role, content: m.content }));
+      const systemMsg = fullMessages.find(m => m.role === 'system') || storedMessages.find(m => m.role === 'system');
+      fullMessages = systemMsg ? [systemMsg] : [];
+      fullMessages.push(...storedMessages.filter(m => m.role !== 'system'));
+      const lastNewUserMsg = messages.filter(m => m.role === 'user').pop();
+      if (lastNewUserMsg && !fullMessages.some(m => m.role === 'user' && m.content === lastNewUserMsg.content)) {
+        fullMessages.push(lastNewUserMsg);
+      }
+    }
+
+    const lastUserMsg = fullMessages.filter(m => m.role === 'user').pop();
+    if (lastUserMsg) addMessageToConversation(conversationId, 'user', lastUserMsg.content);
+
+    const input = buildConversationInput(fullMessages);
+    const requestBody = buildAgentRequest(model, input);
+
+    try {
+      const response = await callYouApi(apiKey, requestBody);
+      const data = await response.json();
+      const resultText = extractText(data);
+      addMessageToConversation(conversationId, 'assistant', resultText);
+
+      return {
+        content: [
+          { type: 'text', text: resultText },
+          { type: 'text', text: `\n\n---\nConversation ID: ${conversationId}` }
+        ],
+      };
+    } catch (error) {
+      markKeyError(apiKey);
+      throw error;
+    }
+  }
+
+  listConversations() {
+    const conversations = [...conversationStore.entries()].map(([id, conv]) => ({
+      id,
+      message_count: conv.messages.length,
+      created_at: new Date(conv.createdAt).toISOString(),
+      updated_at: new Date(conv.updatedAt).toISOString(),
+      preview: conv.messages.slice(-1)[0]?.content?.substring(0, 100) || ''
+    })).sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at));
+
+    return { content: [{ type: 'text', text: JSON.stringify({ total: conversations.length, conversations }, null, 2) }] };
+  }
+
+  getConversationHistory(conversationId) {
+    const conv = getConversation(conversationId);
+    if (!conv) return { content: [{ type: 'text', text: `Conversation not found: ${conversationId}` }] };
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({
+          id: conv.id,
+          messages: conv.messages.map(m => ({ role: m.role, content: m.content, timestamp: new Date(m.timestamp).toISOString() })),
+          created_at: new Date(conv.createdAt).toISOString(),
+          updated_at: new Date(conv.updatedAt).toISOString()
+        }, null, 2)
+      }],
+    };
+  }
+
+  deleteConversation(conversationId) {
+    if (!conversationStore.has(conversationId)) {
+      return { content: [{ type: 'text', text: `Conversation not found: ${conversationId}` }] };
+    }
+    conversationStore.delete(conversationId);
+    return { content: [{ type: 'text', text: `Deleted conversation: ${conversationId}` }] };
+  }
+
+  getKeyStatus() {
+    const status = {
+      total_keys: API_KEYS.length,
+      key_mode: KEY_MODE,
+      current_key_index: currentKeyIndex,
+      keys: API_KEYS.map((key, index) => ({
+        index,
+        key_preview: `${key.substring(0, 8)}...${key.substring(key.length - 4)}`,
+        usage_count: keyUsageCount.get(key) || 0,
+        error_count: keyErrorCount.get(key) || 0,
+        is_current: index === currentKeyIndex
+      }))
+    };
+    return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+  }
+
+  async controlOpenAIServer(args) {
+    const { action, port = 3002, access_tokens = [], store_type, db_path } = args;
+    const openaiServerPath = join(__dirname, 'openai-server.js');
+
+    const jsonResponse = (obj) => ({ content: [{ type: 'text', text: JSON.stringify(obj, null, 2) }] });
+
+    switch (action) {
+      case 'start':
+        if (openaiServerProcess && openaiServerStatus === 'running') {
+          return jsonResponse({ success: false, message: `Already running on port ${openaiServerPort}`, status: openaiServerStatus, port: openaiServerPort });
+        }
+
+        try {
+          const finalStoreType = store_type || OPENAI_SERVER_STORE_TYPE;
+          const finalDbPath = db_path || OPENAI_SERVER_DB_PATH;
+          const finalAccessTokens = access_tokens?.length > 0 ? access_tokens.join(',') : OPENAI_SERVER_ACCESS_TOKENS;
+          
+          const env = { 
+            ...process.env, 
+            YDC_OPENAI_PORT: port.toString(),
+            YDC_API_KEY: API_KEYS[0] || '',
+            YDC_API_KEYS: API_KEYS.join(','),
+            YDC_OPENAI_ACCESS_TOKENS: finalAccessTokens,
+            YDC_CONVERSATION_STORE: finalStoreType,
+            ...(finalDbPath && { YDC_CONVERSATION_DB_PATH: finalDbPath })
+          };
+
+          openaiServerProcess = spawn('node', [openaiServerPath], { env, stdio: ['ignore', 'pipe', 'pipe'], detached: false });
+          openaiServerPort = port;
+          openaiServerStatus = 'starting';
+
+          await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => { openaiServerStatus = 'running'; resolve(); }, 2000);
+            openaiServerProcess.stderr.on('data', (data) => {
+              if (data.toString().includes('running')) { clearTimeout(timeout); openaiServerStatus = 'running'; resolve(); }
+            });
+            openaiServerProcess.on('error', (err) => { clearTimeout(timeout); openaiServerStatus = 'error'; reject(err); });
+            openaiServerProcess.on('exit', (code) => {
+              if (code !== 0 && openaiServerStatus === 'starting') { clearTimeout(timeout); openaiServerStatus = 'stopped'; reject(new Error(`Exit code ${code}`)); }
+            });
+          });
+
+          return jsonResponse({
+            success: true,
+            message: `OpenAI server started on port ${port}`,
+            status: openaiServerStatus,
+            port: openaiServerPort,
+            endpoint: `http://localhost:${port}/v1/chat/completions`,
+            pid: openaiServerProcess.pid,
+            storage: { store_type: finalStoreType, db_path: finalStoreType === 'sqlite' ? (finalDbPath || 'conversations.db') : null },
+            api_keys: { passthrough: API_KEYS.length > 0, count: API_KEYS.length }
+          });
+        } catch (error) {
+          openaiServerStatus = 'error';
+          return jsonResponse({ success: false, message: `Failed to start: ${error.message}`, status: openaiServerStatus });
+        }
+
+      case 'stop':
+        if (!openaiServerProcess || openaiServerStatus === 'stopped') {
+          return jsonResponse({ success: false, message: 'Server is not running', status: openaiServerStatus });
+        }
+        try {
+          openaiServerProcess.kill('SIGTERM');
+          const stoppedPort = openaiServerPort;
+          openaiServerProcess = null;
+          openaiServerPort = null;
+          openaiServerStatus = 'stopped';
+          return jsonResponse({ success: true, message: `Stopped (was on port ${stoppedPort})`, status: openaiServerStatus });
+        } catch (error) {
+          return jsonResponse({ success: false, message: `Failed to stop: ${error.message}`, status: openaiServerStatus });
+        }
+
+      case 'restart':
+        if (openaiServerProcess && openaiServerStatus === 'running') {
+          try { openaiServerProcess.kill('SIGTERM'); openaiServerProcess = null; openaiServerStatus = 'stopped'; await new Promise(r => setTimeout(r, 1000)); } catch {}
+        }
+        return await this.controlOpenAIServer({ action: 'start', port, access_tokens, store_type, db_path });
+
+      case 'status':
+        return jsonResponse({
+          status: openaiServerStatus,
+          port: openaiServerPort,
+          pid: openaiServerProcess?.pid || null,
+          endpoint: openaiServerStatus === 'running' ? `http://localhost:${openaiServerPort}/v1/chat/completions` : null
+        });
+
+      default:
+        return jsonResponse({ success: false, message: `Unknown action: ${action}` });
+    }
+  }
+
+  async run() {
+    if (!validateApiKeys()) process.exit(1);
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error(`You.com Agents MCP server v1.5.0 running on stdio`);
+    console.error(`API Keys: ${API_KEYS.length}, Mode: ${KEY_MODE}`);
+  }
+}
+
+const server = new YouAgentsServer();
+server.run().catch(console.error);
+}