ydc-mcp-server 1.6.1

package/lib/advanced-versions.js

@@ -0,0 +1,113 @@
+/**
+ * Advanced Agent Version System
+ * Provides specialized configurations for different use cases
+ */
+
+export const ADVANCED_VERSIONS = {
+  'advanced-1.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 1,
+    timeout: 120000,
+    tools: []
+  },
+  'advanced-1.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 1,
+    timeout: 120000,
+    tools: []
+  },
+  'advanced-2.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 2,
+    timeout: 180000,
+    tools: []
+  },
+  'advanced-2.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 2,
+    timeout: 180000,
+    tools: []
+  },
+  'advanced-3.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 5,
+    timeout: 180000,
+    tools: [{ type: 'compute' }]
+  },
+  'advanced-3.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 5,
+    timeout: 180000,
+    tools: [{ type: 'compute' }]
+  },
+  'advanced-4.0-medium': {
+    verbosity: 'medium',
+    max_workflow_steps: 6,
+    timeout: 180000,
+    tools: [{ type: 'research', search_effort: 'medium', report_verbosity: 'medium' }]
+  },
+  'advanced-4.0-high': {
+    verbosity: 'high',
+    max_workflow_steps: 6,
+    timeout: 180000,
+    tools: [{ type: 'research', search_effort: 'high', report_verbosity: 'high' }]
+  },
+  'advanced-4.5-medium-research': {
+    verbosity: 'medium',
+    max_workflow_steps: 9,
+    timeout: 300000,
+    tools: [
+      { type: 'compute' },
+      { type: 'research', search_effort: 'medium', report_verbosity: 'medium' }
+    ]
+  },
+  'advanced-4.5-high-research': {
+    verbosity: 'high',
+    max_workflow_steps: 9,
+    timeout: 300000,
+    tools: [
+      { type: 'compute' },
+      { type: 'research', search_effort: 'high', report_verbosity: 'high' }
+    ]
+  }
+};
+
+export function getAdvancedVersion(versionName) {
+  return ADVANCED_VERSIONS[versionName] || null;
+}
+
+export function isAdvancedVersion(modelName) {
+  return modelName in ADVANCED_VERSIONS;
+}
+
+export function getDefaultAdvancedVersion(temperature = 0.7) {
+  return temperature <= 0.5 ? 'advanced-3.0-medium' : 'advanced-3.0-high';
+}
+
+export function adjustWorkflowSteps(baseSteps, temperature) {
+  const adjustment = Math.round((temperature - 0.5) * 4);
+  return Math.max(1, Math.min(20, baseSteps + adjustment));
+}
+
+export function listAdvancedVersions() {
+  return Object.keys(ADVANCED_VERSIONS);
+}
+
+export function getVersionInfo(versionName) {
+  const config = ADVANCED_VERSIONS[versionName];
+  if (!config) return null;
+  
+  const toolNames = config.tools.map(t => {
+    if (t.type === 'research') return `research(${t.search_effort})`;
+    return t.type;
+  }).join(', ') || 'none';
+
+  return {
+    name: versionName,
+    verbosity: config.verbosity,
+    max_workflow_steps: config.max_workflow_steps,
+    timeout_seconds: config.timeout / 1000,
+    tools: toolNames,
+    description: `${config.verbosity} verbosity, ${config.max_workflow_steps} steps, ${config.timeout/1000}s timeout`
+  };
+}

package/lib/api-client.js

@@ -0,0 +1,134 @@
+/**
+ * You.com API Client Module
+ * Shared API calling logic for MCP and OpenAI servers
+ */
+
+const API_BASE = 'https://api.you.com/v1/agents/runs';
+
+// Agent type configurations
+export const AGENT_TYPES = {
+  'express': { agent: 'express', description: 'Fast AI answers with web search' },
+  'research': { agent: 'research', description: 'In-depth research and analysis' },
+  'advanced': { agent: 'advanced', description: 'Complex reasoning with tools' },
+  'advanced-3.0-high': { agent: 'advanced', verbosity: 'high', max_workflow_steps: 15 },
+  'advanced-3.0-medium': { agent: 'advanced', verbosity: 'medium', max_workflow_steps: 10 },
+  'advanced-4.0-high': { agent: 'advanced', verbosity: 'high', max_workflow_steps: 20 },
+  'advanced-4.5-research': { 
+    agent: 'advanced', 
+    verbosity: 'high', 
+    max_workflow_steps: 20, 
+    tools: [{ type: 'research', search_effort: 'high', report_verbosity: 'high' }, { type: 'compute' }] 
+  }
+};
+
+/**
+ * Call You.com API
+ */
+export async function callYouApi(apiKey, requestBody, options = {}) {
+  const { timeout = 300000 } = options;
+  
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(API_BASE, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} ${errorText}`);
+    }
+
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    throw error;
+  }
+}
+
+/**
+ * Extract text from You.com response
+ */
+export function extractText(data) {
+  if (data.output && Array.isArray(data.output)) {
+    return data.output
+      .filter(item => item.type === 'message.answer')
+      .map(item => item.text)
+      .join('\n\n');
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+/**
+ * Build conversation input from messages
+ */
+export function buildConversationInput(messages) {
+  let input = '';
+  let systemPrompt = '';
+  const conversationHistory = [];
+  
+  messages.forEach(msg => {
+    if (msg.role === 'system') {
+      systemPrompt = msg.content;
+    } else if (msg.role === 'user') {
+      conversationHistory.push(`User: ${msg.content}`);
+    } else if (msg.role === 'assistant') {
+      conversationHistory.push(`Assistant: ${msg.content}`);
+    }
+  });
+  
+  if (systemPrompt) {
+    input = `[System Instructions]\n${systemPrompt}\n\n`;
+  }
+  
+  if (conversationHistory.length > 1) {
+    input += `[Conversation History]\n${conversationHistory.slice(0, -1).join('\n\n')}\n\n`;
+    input += `[Current Message]\n${conversationHistory[conversationHistory.length - 1].replace(/^User: /, '')}`;
+  } else if (conversationHistory.length === 1) {
+    input += conversationHistory[0].replace(/^User: /, '');
+  }
+
+  return input;
+}
+
+/**
+ * Build request body for agent call
+ */
+export function buildAgentRequest(agentType, input, options = {}) {
+  const { tools, verbosity, max_workflow_steps, stream = false } = options;
+  const agentConfig = AGENT_TYPES[agentType] || AGENT_TYPES['advanced-3.0-high'];
+  const isExpressAgent = agentType === 'express' || agentConfig.agent === 'express';
+
+  if (isExpressAgent) {
+    return {
+      agent: 'express',
+      input,
+      stream,
+    };
+  }
+
+  return {
+    agent: agentConfig.agent || 'advanced',
+    input,
+    stream,
+    verbosity: verbosity || agentConfig.verbosity || 'high',
+    tools: tools || agentConfig.tools || [
+      { type: 'research', search_effort: 'high', report_verbosity: 'high' },
+      { type: 'compute' }
+    ],
+    workflow_config: {
+      max_workflow_steps: max_workflow_steps || agentConfig.max_workflow_steps || 15
+    },
+  };
+}
+
+export { API_BASE };

package/lib/auth-middleware.js

@@ -0,0 +1,44 @@
+/**
+ * Authentication Middleware Module
+ */
+
+// Access token configuration
+const ACCESS_TOKENS_RAW = process.env.YDC_OPENAI_ACCESS_TOKENS || '';
+const ACCESS_TOKENS = ACCESS_TOKENS_RAW.split(',').map(t => t.trim()).filter(t => t);
+const REQUIRE_TOKEN_AUTH = ACCESS_TOKENS.length > 0;
+
+/**
+ * Authentication middleware for Express
+ */
+export function authenticate(req, res, next) {
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({
+      error: {
+        message: 'Invalid authentication credentials',
+        type: 'invalid_request_error',
+        code: 'invalid_api_key'
+      }
+    });
+  }
+
+  if (REQUIRE_TOKEN_AUTH) {
+    const token = authHeader.slice(7);
+    if (!ACCESS_TOKENS.includes(token)) {
+      return res.status(401).json({
+        error: {
+          message: 'Invalid access token',
+          type: 'invalid_request_error',
+          code: 'invalid_access_token'
+        }
+      });
+    }
+  }
+
+  next();
+}
+
+export const authConfig = {
+  REQUIRE_TOKEN_AUTH,
+  ACCESS_TOKENS_COUNT: ACCESS_TOKENS.length
+};

package/lib/conversation-store.js

@@ -0,0 +1,271 @@
+/**
+ * Conversation Store Module
+ * Supports SQLite (persistent) and Memory (in-memory) storage
+ */
+
+import Database from 'better-sqlite3';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import crypto from 'crypto';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Configuration
+const STORE_TYPE = process.env.YDC_CONVERSATION_STORE || 'sqlite';
+const DB_PATH = process.env.YDC_CONVERSATION_DB_PATH || join(__dirname, '..', 'conversations.db');
+const CONVERSATION_TTL = 24 * 60 * 60 * 1000; // 24 hours
+const MAX_CONVERSATIONS = 1000;
+const MAX_MESSAGES_PER_CONVERSATION = 100;
+
+// Memory store (fallback)
+const memoryStore = new Map();
+
+// SQLite database
+let db = null;
+
+function initDatabase() {
+  if (STORE_TYPE === 'memory') {
+    console.log('📦 Using in-memory conversation store');
+    return;
+  }
+
+  try {
+    db = new Database(DB_PATH);
+    
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS conversations (
+        id TEXT PRIMARY KEY,
+        metadata TEXT DEFAULT '{}',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversation_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+      );
+      
+      CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id);
+      CREATE INDEX IF NOT EXISTS idx_conversations_updated ON conversations(updated_at);
+    `);
+    
+    console.log(`📦 Using SQLite conversation store: ${DB_PATH}`);
+  } catch (error) {
+    console.error('⚠️ Failed to initialize SQLite, falling back to memory store:', error.message);
+    db = null;
+  }
+}
+
+// Initialize database
+initDatabase();
+
+export function generateConversationId() {
+  return crypto.randomUUID();
+}
+
+export function getConversation(conversationId) {
+  if (!conversationId) return null;
+
+  if (STORE_TYPE === 'memory' || !db) {
+    if (!memoryStore.has(conversationId)) return null;
+    const conv = memoryStore.get(conversationId);
+    conv.updatedAt = Date.now();
+    return conv;
+  }
+
+  const conv = db.prepare('SELECT * FROM conversations WHERE id = ?').get(conversationId);
+  if (!conv) return null;
+
+  const messages = db.prepare('SELECT role, content, timestamp FROM messages WHERE conversation_id = ? ORDER BY id').all(conversationId);
+  db.prepare('UPDATE conversations SET updated_at = ? WHERE id = ?').run(Date.now(), conversationId);
+
+  return {
+    id: conv.id,
+    messages,
+    metadata: JSON.parse(conv.metadata || '{}'),
+    createdAt: conv.created_at,
+    updatedAt: Date.now()
+  };
+}
+
+export function createConversation(conversationId = null, metadata = {}) {
+  const id = conversationId || generateConversationId();
+  const now = Date.now();
+
+  if (STORE_TYPE === 'memory' || !db) {
+    const conv = { id, messages: [], createdAt: now, updatedAt: now, metadata };
+    memoryStore.set(id, conv);
+    return conv;
+  }
+
+  db.prepare('INSERT OR REPLACE INTO conversations (id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?)')
+    .run(id, JSON.stringify(metadata), now, now);
+
+  return { id, messages: [], createdAt: now, updatedAt: now, metadata };
+}
+
+export function addMessageToConversation(conversationId, role, content) {
+  const now = Date.now();
+
+  if (STORE_TYPE === 'memory' || !db) {
+    let conv = memoryStore.get(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: now });
+    conv.updatedAt = now;
+    return conv;
+  }
+
+  const existing = db.prepare('SELECT id FROM conversations WHERE id = ?').get(conversationId);
+  if (!existing) {
+    createConversation(conversationId);
+  }
+
+  const count = db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conversationId).count;
+  if (count >= MAX_MESSAGES_PER_CONVERSATION) {
+    const systemMsg = db.prepare("SELECT id FROM messages WHERE conversation_id = ? AND role = 'system' LIMIT 1").get(conversationId);
+    const deleteCount = count - MAX_MESSAGES_PER_CONVERSATION + 2;
+    
+    if (systemMsg) {
+      db.prepare('DELETE FROM messages WHERE conversation_id = ? AND id != ? ORDER BY id LIMIT ?')
+        .run(conversationId, systemMsg.id, deleteCount);
+    } else {
+      db.prepare('DELETE FROM messages WHERE conversation_id = ? ORDER BY id LIMIT ?')
+        .run(conversationId, deleteCount);
+    }
+  }
+
+  db.prepare('INSERT INTO messages (conversation_id, role, content, timestamp) VALUES (?, ?, ?, ?)')
+    .run(conversationId, role, content, now);
+  
+  db.prepare('UPDATE conversations SET updated_at = ? WHERE id = ?').run(now, conversationId);
+
+  return getConversation(conversationId);
+}
+
+export function listAllConversations() {
+  if (STORE_TYPE === 'memory' || !db) {
+    const conversations = [];
+    for (const [id, conv] of memoryStore.entries()) {
+      conversations.push({
+        id,
+        message_count: conv.messages.length,
+        created_at: new Date(conv.createdAt).toISOString(),
+        updated_at: new Date(conv.updatedAt).toISOString(),
+        metadata: conv.metadata,
+        preview: conv.messages.slice(-1)[0]?.content?.substring(0, 100) || ''
+      });
+    }
+    return conversations.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at));
+  }
+
+  const convs = db.prepare('SELECT * FROM conversations ORDER BY updated_at DESC').all();
+  return convs.map(conv => {
+    const lastMsg = db.prepare('SELECT content FROM messages WHERE conversation_id = ? ORDER BY id DESC LIMIT 1').get(conv.id);
+    const msgCount = db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conv.id).count;
+    return {
+      id: conv.id,
+      message_count: msgCount,
+      created_at: new Date(conv.created_at).toISOString(),
+      updated_at: new Date(conv.updated_at).toISOString(),
+      metadata: JSON.parse(conv.metadata || '{}'),
+      preview: lastMsg?.content?.substring(0, 100) || ''
+    };
+  });
+}
+
+export function deleteConversation(conversationId) {
+  if (STORE_TYPE === 'memory' || !db) {
+    return memoryStore.delete(conversationId);
+  }
+
+  db.prepare('DELETE FROM messages WHERE conversation_id = ?').run(conversationId);
+  const result = db.prepare('DELETE FROM conversations WHERE id = ?').run(conversationId);
+  return result.changes > 0;
+}
+
+export function clearAllConversations() {
+  if (STORE_TYPE === 'memory' || !db) {
+    const count = memoryStore.size;
+    memoryStore.clear();
+    return count;
+  }
+
+  const count = db.prepare('SELECT COUNT(*) as count FROM conversations').get().count;
+  db.prepare('DELETE FROM messages').run();
+  db.prepare('DELETE FROM conversations').run();
+  return count;
+}
+
+export function getConversationCount() {
+  if (STORE_TYPE === 'memory' || !db) {
+    return memoryStore.size;
+  }
+  return db.prepare('SELECT COUNT(*) as count FROM conversations').get().count;
+}
+
+export function cleanupConversations() {
+  const now = Date.now();
+  const expireTime = now - CONVERSATION_TTL;
+
+  if (STORE_TYPE === 'memory' || !db) {
+    let deleted = 0;
+    for (const [id, conv] of memoryStore.entries()) {
+      if (conv.updatedAt < expireTime) {
+        memoryStore.delete(id);
+        deleted++;
+      }
+    }
+    
+    if (memoryStore.size > MAX_CONVERSATIONS) {
+      const sorted = [...memoryStore.entries()].sort((a, b) => a[1].updatedAt - b[1].updatedAt);
+      const toDelete = sorted.slice(0, memoryStore.size - MAX_CONVERSATIONS);
+      toDelete.forEach(([id]) => memoryStore.delete(id));
+      deleted += toDelete.length;
+    }
+    return deleted;
+  }
+
+  const expiredConvs = db.prepare('SELECT id FROM conversations WHERE updated_at < ?').all(expireTime);
+  for (const conv of expiredConvs) {
+    db.prepare('DELETE FROM messages WHERE conversation_id = ?').run(conv.id);
+  }
+  let result = db.prepare('DELETE FROM conversations WHERE updated_at < ?').run(expireTime);
+  let deleted = result.changes;
+
+  const count = db.prepare('SELECT COUNT(*) as count FROM conversations').get().count;
+  if (count > MAX_CONVERSATIONS) {
+    const toDelete = db.prepare('SELECT id FROM conversations ORDER BY updated_at ASC LIMIT ?').all(count - MAX_CONVERSATIONS);
+    for (const conv of toDelete) {
+      db.prepare('DELETE FROM messages WHERE conversation_id = ?').run(conv.id);
+      db.prepare('DELETE FROM conversations WHERE id = ?').run(conv.id);
+      deleted++;
+    }
+  }
+
+  return deleted;
+}
+
+// Run cleanup every hour
+setInterval(cleanupConversations, 60 * 60 * 1000);
+
+// Export config for health check
+export const storeConfig = {
+  STORE_TYPE,
+  DB_PATH,
+  MAX_CONVERSATIONS,
+  CONVERSATION_TTL,
+  isDbConnected: () => !!db
+};