ydc-mcp-server 1.6.1 → 1.7.8

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

package/lib/anthropic-mapper.js

@@ -0,0 +1,255 @@
+/**
+ * Anthropic/Claude Parameter Mapper Module
+ * Maps Anthropic API parameters to You.com API parameters
+ */
+
+import { 
+  getAdvancedVersion, 
+  isAdvancedVersion, 
+  getDefaultAdvancedVersion,
+  adjustWorkflowSteps
+} from './advanced-versions.js';
+
+/**
+ * Map Anthropic request parameters to You.com parameters
+ */
+export function mapAnthropicToYouParams(anthropicRequest) {
+  const {
+    model = 'advanced-3.0-high',
+    messages,
+    system,
+    temperature = 0.7,
+    max_tokens = 1024,
+    stream = false
+  } = anthropicRequest;
+
+  let input = '';
+  const conversationHistory = [];
+  
+  // Handle system prompt
+  if (system) {
+    input = `[System Instructions]\n${system}\n\n`;
+  }
+  
+  // Process messages
+  messages.forEach(msg => {
+    if (msg.role === 'user') {
+      // Handle content as string or array
+      const content = typeof msg.content === 'string' 
+        ? msg.content 
+        : msg.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+      conversationHistory.push(`User: ${content}`);
+    } else if (msg.role === 'assistant') {
+      const content = typeof msg.content === 'string'
+        ? msg.content
+        : msg.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+      conversationHistory.push(`Assistant: ${content}`);
+    }
+  });
+  
+  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: /, '');
+  }
+
+  // Map model to You.com agent
+  const modelMapping = {
+    'claude-3-opus-20240229': 'advanced-3.0-high',
+    'claude-3-sonnet-20240229': 'advanced-3.0-medium',
+    'claude-3-haiku-20240307': 'express',
+    'claude-3-5-sonnet-20240620': 'advanced-3.0-high',
+    'claude-3-5-sonnet-20241022': 'advanced-3.0-high',
+    'claude-sonnet-4-20250514': 'advanced-3.0-high',
+    'claude-sonnet-4-5-20250929': 'advanced-4.5-research'
+  };
+
+  const mappedModel = modelMapping[model] || model;
+
+  // Check if it's an advanced version model
+  if (isAdvancedVersion(mappedModel)) {
+    const versionConfig = getAdvancedVersion(mappedModel);
+    if (versionConfig) {
+      const adjustedSteps = adjustWorkflowSteps(versionConfig.max_workflow_steps, temperature);
+      
+      return {
+        agent: 'advanced',
+        input,
+        stream,
+        verbosity: versionConfig.verbosity,
+        tools: versionConfig.tools,
+        workflow_config: {
+          max_workflow_steps: adjustedSteps
+        },
+        timeout: versionConfig.timeout
+      };
+    }
+  }
+
+  // Default handling
+  let agent = mappedModel;
+  let verbosity = 'medium';
+  let timeout = 300000;
+
+  if (temperature <= 0.3) verbosity = 'medium';
+  else if (temperature >= 0.8) verbosity = 'high';
+
+  const max_workflow_steps = Math.min(Math.max(Math.floor(max_tokens / 100), 1), 20);
+
+  const knownAgents = ['express', 'research', 'advanced'];
+  if (!knownAgents.includes(agent)) {
+    agent = 'advanced';
+  }
+
+  if (agent === 'advanced') {
+    timeout = 3000000;
+  }
+
+  return {
+    agent,
+    input,
+    stream,
+    verbosity,
+    tools: [
+      { type: 'research', search_effort: 'auto', report_verbosity: 'medium' },
+      { type: 'compute' }
+    ],
+    workflow_config: {
+      max_workflow_steps
+    },
+    timeout
+  };
+}
+
+/**
+ * Convert You.com response to Anthropic format
+ */
+export function convertToAnthropicResponse(youResponse, model, inputTokens = 100) {
+  const content = youResponse.output && Array.isArray(youResponse.output)
+    ? youResponse.output
+        .filter(item => item.type === 'message.answer')
+        .map(item => item.text)
+        .join('\n\n')
+    : 'No response content';
+
+  const outputTokens = Math.floor(content.length / 4);
+
+  return {
+    id: `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    content: [
+      {
+        type: 'text',
+        text: content
+      }
+    ],
+    model: model,
+    stop_reason: 'end_turn',
+    stop_sequence: null,
+    usage: {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    }
+  };
+}
+
+/**
+ * Create streaming event in Anthropic format
+ */
+export function createAnthropicStreamEvent(eventType, data) {
+  return `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+/**
+ * Create message_start event
+ */
+export function createMessageStartEvent(model, conversationId = null) {
+  const message = {
+    id: `msg_${Date.now()}`,
+    type: 'message',
+    role: 'assistant',
+    content: [],
+    model: model,
+    stop_reason: null,
+    stop_sequence: null,
+    usage: {
+      input_tokens: 0,
+      output_tokens: 0
+    }
+  };
+  
+  // Add conversation_id in metadata if provided
+  if (conversationId) {
+    message.metadata = { conversation_id: conversationId };
+  }
+  
+  return createAnthropicStreamEvent('message_start', {
+    type: 'message_start',
+    message
+  });
+}
+
+/**
+ * Create content_block_start event
+ */
+export function createContentBlockStartEvent(index = 0) {
+  return createAnthropicStreamEvent('content_block_start', {
+    type: 'content_block_start',
+    index: index,
+    content_block: {
+      type: 'text',
+      text: ''
+    }
+  });
+}
+
+/**
+ * Create content_block_delta event
+ */
+export function createContentBlockDeltaEvent(text, index = 0) {
+  return createAnthropicStreamEvent('content_block_delta', {
+    type: 'content_block_delta',
+    index: index,
+    delta: {
+      type: 'text_delta',
+      text: text
+    }
+  });
+}
+
+/**
+ * Create content_block_stop event
+ */
+export function createContentBlockStopEvent(index = 0) {
+  return createAnthropicStreamEvent('content_block_stop', {
+    type: 'content_block_stop',
+    index: index
+  });
+}
+
+/**
+ * Create message_delta event
+ */
+export function createMessageDeltaEvent(outputTokens = 0) {
+  return createAnthropicStreamEvent('message_delta', {
+    type: 'message_delta',
+    delta: {
+      stop_reason: 'end_turn',
+      stop_sequence: null
+    },
+    usage: {
+      output_tokens: outputTokens
+    }
+  });
+}
+
+/**
+ * Create message_stop event
+ */
+export function createMessageStopEvent() {
+  return createAnthropicStreamEvent('message_stop', {
+    type: 'message_stop'
+  });
+}

package/lib/conversation-store.js

@@ -1,11 +1,11 @@
 /**
  * Conversation Store Module
- * Supports SQLite (persistent) and Memory (in-memory) storage
+ * Supports SQLite (persistent via sql.js) and Memory (in-memory) storage
  */
 
-import Database from 'better-sqlite3';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import crypto from 'crypto';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -21,26 +21,66 @@ const MAX_MESSAGES_PER_CONVERSATION = 100;
 // Memory store (fallback)
 const memoryStore = new Map();
 
-// SQLite database
+// SQLite database (sql.js)
 let db = null;
+let SQL = null;
+let dbInitialized = false;
+
+// Save database to file periodically
+let saveTimeout = null;
+function scheduleSave() {
+  if (saveTimeout) clearTimeout(saveTimeout);
+  saveTimeout = setTimeout(() => {
+    if (db && STORE_TYPE === 'sqlite') {
+      try {
+        const data = db.export();
+        writeFileSync(DB_PATH, Buffer.from(data));
+      } catch (error) {
+        console.error('⚠️ Failed to save database:', error.message);
+      }
+    }
+  }, 1000); // Debounce saves by 1 second
+}
+
+async function initDatabase() {
+  if (dbInitialized) return;
+  dbInitialized = true;
 
-function initDatabase() {
   if (STORE_TYPE === 'memory') {
     console.log('📦 Using in-memory conversation store');
     return;
   }
 
   try {
-    db = new Database(DB_PATH);
+    // Dynamic import sql.js
+    const initSqlJs = (await import('sql.js')).default;
+    SQL = await initSqlJs();
     
-    db.exec(`
+    // Load existing database or create new one
+    if (existsSync(DB_PATH)) {
+      try {
+        const fileBuffer = readFileSync(DB_PATH);
+        db = new SQL.Database(fileBuffer);
+        console.log(`📦 Loaded SQLite database: ${DB_PATH}`);
+      } catch (error) {
+        console.error('⚠️ Failed to load existing database, creating new one:', error.message);
+        db = new SQL.Database();
+      }
+    } else {
+      db = new SQL.Database();
+    }
+    
+    // Create tables
+    db.run(`
       CREATE TABLE IF NOT EXISTS conversations (
         id TEXT PRIMARY KEY,
         metadata TEXT DEFAULT '{}',
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
-      );
-      
+      )
+    `);
+    
+    db.run(`
       CREATE TABLE IF NOT EXISTS messages (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         conversation_id TEXT NOT NULL,
@@ -48,12 +88,15 @@ function initDatabase() {
         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);
+      )
     `);
     
+    db.run(`CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id)`);
+    db.run(`CREATE INDEX IF NOT EXISTS idx_conversations_updated ON conversations(updated_at)`);
+    
+    // Save initial database
+    scheduleSave();
+    
     console.log(`📦 Using SQLite conversation store: ${DB_PATH}`);
   } catch (error) {
     console.error('⚠️ Failed to initialize SQLite, falling back to memory store:', error.message);
@@ -61,8 +104,8 @@ function initDatabase() {
   }
 }
 
-// Initialize database
-initDatabase();
+// Export init function for async initialization
+export { initDatabase };
 
 export function generateConversationId() {
   return crypto.randomUUID();
@@ -78,17 +121,27 @@ export function getConversation(conversationId) {
     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);
+  const convResult = db.exec('SELECT * FROM conversations WHERE id = ?', [conversationId]);
+  if (!convResult.length || !convResult[0].values.length) return null;
+  
+  const conv = convResult[0].values[0];
+  const [id, metadata, created_at, updated_at] = conv;
+
+  const messagesResult = db.exec('SELECT role, content, timestamp FROM messages WHERE conversation_id = ? ORDER BY id', [conversationId]);
+  const messages = messagesResult.length ? messagesResult[0].values.map(row => ({
+    role: row[0],
+    content: row[1],
+    timestamp: row[2]
+  })) : [];
+  
+  db.run('UPDATE conversations SET updated_at = ? WHERE id = ?', [Date.now(), conversationId]);
+  scheduleSave();
 
   return {
-    id: conv.id,
+    id,
     messages,
-    metadata: JSON.parse(conv.metadata || '{}'),
-    createdAt: conv.created_at,
+    metadata: JSON.parse(metadata || '{}'),
+    createdAt: created_at,
     updatedAt: Date.now()
   };
 }
@@ -103,8 +156,9 @@ export function createConversation(conversationId = null, metadata = {}) {
     return conv;
   }
 
-  db.prepare('INSERT OR REPLACE INTO conversations (id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?)')
-    .run(id, JSON.stringify(metadata), now, now);
+  db.run('INSERT OR REPLACE INTO conversations (id, metadata, created_at, updated_at) VALUES (?, ?, ?, ?)',
+    [id, JSON.stringify(metadata), now, now]);
+  scheduleSave();
 
   return { id, messages: [], createdAt: now, updatedAt: now, metadata };
 }
@@ -128,33 +182,49 @@ export function addMessageToConversation(conversationId, role, content) {
     return conv;
   }
 
-  const existing = db.prepare('SELECT id FROM conversations WHERE id = ?').get(conversationId);
-  if (!existing) {
+  const existing = db.exec('SELECT id FROM conversations WHERE id = ?', [conversationId]);
+  if (!existing.length || !existing[0].values.length) {
     createConversation(conversationId);
   }
 
-  const count = db.prepare('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?').get(conversationId).count;
+  const countResult = db.exec('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?', [conversationId]);
+  const count = countResult.length ? countResult[0].values[0][0] : 0;
+  
   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 systemMsgResult = db.exec("SELECT id FROM messages WHERE conversation_id = ? AND role = 'system' LIMIT 1", [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);
+    if (systemMsgResult.length && systemMsgResult[0].values.length) {
+      const systemId = systemMsgResult[0].values[0][0];
+      // Delete oldest messages except system message
+      const toDeleteResult = db.exec('SELECT id FROM messages WHERE conversation_id = ? AND id != ? ORDER BY id LIMIT ?', 
+        [conversationId, systemId, deleteCount]);
+      if (toDeleteResult.length) {
+        toDeleteResult[0].values.forEach(row => {
+          db.run('DELETE FROM messages WHERE id = ?', [row[0]]);
+        });
+      }
     } else {
-      db.prepare('DELETE FROM messages WHERE conversation_id = ? ORDER BY id LIMIT ?')
-        .run(conversationId, deleteCount);
+      const toDeleteResult = db.exec('SELECT id FROM messages WHERE conversation_id = ? ORDER BY id LIMIT ?', 
+        [conversationId, deleteCount]);
+      if (toDeleteResult.length) {
+        toDeleteResult[0].values.forEach(row => {
+          db.run('DELETE FROM messages WHERE id = ?', [row[0]]);
+        });
+      }
     }
   }
 
-  db.prepare('INSERT INTO messages (conversation_id, role, content, timestamp) VALUES (?, ?, ?, ?)')
-    .run(conversationId, role, content, now);
+  db.run('INSERT INTO messages (conversation_id, role, content, timestamp) VALUES (?, ?, ?, ?)',
+    [conversationId, role, content, now]);
   
-  db.prepare('UPDATE conversations SET updated_at = ? WHERE id = ?').run(now, conversationId);
+  db.run('UPDATE conversations SET updated_at = ? WHERE id = ?', [now, conversationId]);
+  scheduleSave();
 
   return getConversation(conversationId);
 }
 
+
 export function listAllConversations() {
   if (STORE_TYPE === 'memory' || !db) {
     const conversations = [];
@@ -171,17 +241,21 @@ export function listAllConversations() {
     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;
+  const convsResult = db.exec('SELECT * FROM conversations ORDER BY updated_at DESC');
+  if (!convsResult.length) return [];
+  
+  return convsResult[0].values.map(conv => {
+    const [id, metadata, created_at, updated_at] = conv;
+    const lastMsgResult = db.exec('SELECT content FROM messages WHERE conversation_id = ? ORDER BY id DESC LIMIT 1', [id]);
+    const msgCountResult = db.exec('SELECT COUNT(*) as count FROM messages WHERE conversation_id = ?', [id]);
+    
     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) || ''
+      id,
+      message_count: msgCountResult.length ? msgCountResult[0].values[0][0] : 0,
+      created_at: new Date(created_at).toISOString(),
+      updated_at: new Date(updated_at).toISOString(),
+      metadata: JSON.parse(metadata || '{}'),
+      preview: lastMsgResult.length && lastMsgResult[0].values.length ? lastMsgResult[0].values[0][0]?.substring(0, 100) || '' : ''
     };
   });
 }
@@ -191,9 +265,10 @@ export function deleteConversation(conversationId) {
     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;
+  db.run('DELETE FROM messages WHERE conversation_id = ?', [conversationId]);
+  db.run('DELETE FROM conversations WHERE id = ?', [conversationId]);
+  scheduleSave();
+  return true;
 }
 
 export function clearAllConversations() {
@@ -203,9 +278,11 @@ export function clearAllConversations() {
     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();
+  const countResult = db.exec('SELECT COUNT(*) as count FROM conversations');
+  const count = countResult.length ? countResult[0].values[0][0] : 0;
+  db.run('DELETE FROM messages');
+  db.run('DELETE FROM conversations');
+  scheduleSave();
   return count;
 }
 
@@ -213,7 +290,8 @@ export function getConversationCount() {
   if (STORE_TYPE === 'memory' || !db) {
     return memoryStore.size;
   }
-  return db.prepare('SELECT COUNT(*) as count FROM conversations').get().count;
+  const result = db.exec('SELECT COUNT(*) as count FROM conversations');
+  return result.length ? result[0].values[0][0] : 0;
 }
 
 export function cleanupConversations() {
@@ -238,23 +316,32 @@ export function cleanupConversations() {
     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);
+  // Delete expired conversations
+  const expiredResult = db.exec('SELECT id FROM conversations WHERE updated_at < ?', [expireTime]);
+  let deleted = 0;
+  if (expiredResult.length) {
+    expiredResult[0].values.forEach(row => {
+      db.run('DELETE FROM messages WHERE conversation_id = ?', [row[0]]);
+      db.run('DELETE FROM conversations WHERE id = ?', [row[0]]);
+      deleted++;
+    });
   }
-  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;
+  // Enforce max conversations limit
+  const countResult = db.exec('SELECT COUNT(*) as count FROM conversations');
+  const count = countResult.length ? countResult[0].values[0][0] : 0;
   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++;
+    const toDeleteResult = db.exec('SELECT id FROM conversations ORDER BY updated_at ASC LIMIT ?', [count - MAX_CONVERSATIONS]);
+    if (toDeleteResult.length) {
+      toDeleteResult[0].values.forEach(row => {
+        db.run('DELETE FROM messages WHERE conversation_id = ?', [row[0]]);
+        db.run('DELETE FROM conversations WHERE id = ?', [row[0]]);
+        deleted++;
+      });
     }
   }
 
+  if (deleted > 0) scheduleSave();
   return deleted;
 }
 

package/lib/request-logger.js

@@ -0,0 +1,80 @@
+/**
+ * Request Logger Module
+ * Pretty prints request/response info using cli-table3
+ */
+
+import { getConversation } from './conversation-store.js';
+
+let Table;
+let tableAvailable = false;
+
+// Try to load cli-table3 (optional dependency)
+try {
+  Table = (await import('cli-table3')).default;
+  tableAvailable = true;
+} catch (e) {
+  // cli-table3 not available, use simple logging
+}
+
+/**
+ * Log stream complete with full info and input stack table
+ */
+export function logStreamComplete(info) {
+  const {
+    conversationId,
+    contentLength = 0,
+    messageCount = 0,
+    agent = 'unknown',
+    stream = true
+  } = info;
+
+  const streamMode = stream ? 'stream' : 'sync';
+  
+  // Main info line
+  console.log(`📥 Complete: Conv. ID ${conversationId}, ${contentLength} chars, Messages: ${messageCount}`);
+  console.log(`   ${agent}(${streamMode})`);
+
+  // Get history from conversation store
+  const conv = getConversation(conversationId);
+  const history = conv?.messages || [];
+  
+  if (history.length > 0 && tableAvailable) {
+    const table = new Table({
+      head: ['#', 'Role', 'Content'],
+      colWidths: [4, 12, 60],
+      style: { head: ['cyan'] },
+      wordWrap: true
+    });
+
+    history.forEach((item, index) => {
+      const preview = item.content.length > 80 ? item.content.substring(0, 80) + '...' : item.content;
+      table.push([index + 1, item.role, preview]);
+    });
+
+    console.log('   Input Stack:');
+    console.log(table.toString());
+  } else if (history.length > 0) {
+    console.log('   Input Stack:');
+    history.forEach((item, index) => {
+      const preview = item.content.length > 50 ? item.content.substring(0, 50) + '...' : item.content;
+      console.log(`   ${index + 1}. [${item.role}] ${preview}`);
+    });
+  }
+  
+  console.log(''); // Empty line for separation
+}
+
+/**
+ * Log request (simplified)
+ */
+export function logRequest(info) {
+  const { conversationId } = info;
+  console.log(`📤 Request: Conv. ID ${conversationId || 'new'}`);
+}
+
+/**
+ * Log response (for non-streaming)
+ */
+export function logResponse(info) {
+  logStreamComplete(info);
+}

package/lib/routes/anthropic-messages.js

@@ -0,0 +1,248 @@
+/**
+ * Anthropic Messages Route
+ * Handles /v1/messages endpoint (Anthropic/Claude API compatible)
+ */
+
+import { Router } from 'express';
+import { callYouApi } from '../api-client.js';
+import { 
+  mapAnthropicToYouParams, 
+  convertToAnthropicResponse,
+  createMessageStartEvent,
+  createContentBlockStartEvent,
+  createContentBlockDeltaEvent,
+  createContentBlockStopEvent,
+  createMessageDeltaEvent,
+  createMessageStopEvent
+} from '../anthropic-mapper.js';
+import {
+  getConversation,
+  createConversation,
+  addMessageToConversation,
+  generateConversationId
+} from '../conversation-store.js';
+import { logRequest, logStreamComplete, logResponse } from '../request-logger.js';
+
+const router = Router();
+
+// Get API key with rotation support
+function getApiKey() {
+  const keys = (process.env.YDC_API_KEYS || process.env.YDC_API_KEY || '').split(',').filter(k => k.trim());
+  if (keys.length === 0) throw new Error('No API key configured');
+  return keys[Math.floor(Math.random() * keys.length)].trim();
+}
+
+// Anthropic Messages endpoint
+router.post('/v1/messages', async (req, res) => {
+  try {
+    const { 
+      model = 'claude-3-5-sonnet-20241022',
+      messages,
+      system,
+      max_tokens = 1024,
+      temperature = 0.7,
+      stream = false,
+      metadata
+    } = req.body;
+
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+      return res.status(400).json({
+        type: 'error',
+        error: {
+          type: 'invalid_request_error',
+          message: 'messages is required and must be a non-empty array'
+        }
+      });
+    }
+
+    const apiKey = getApiKey();
+    
+    // Handle conversation persistence via metadata or generate new one
+    let conversationId = metadata?.conversation_id || generateConversationId();
+    const existingConv = getConversation(conversationId);
+    if (!existingConv) {
+      createConversation(conversationId);
+    }
+
+    // Map to You.com parameters
+    const youParams = mapAnthropicToYouParams({
+      model,
+      messages,
+      system,
+      temperature,
+      max_tokens,
+      stream
+    });
+
+    // Get current user input for logging
+    const lastUserMsg = messages.filter(m => m.role === 'user').pop();
+    const currentInput = typeof lastUserMsg?.content === 'string' 
+      ? lastUserMsg.content 
+      : lastUserMsg?.content?.filter(c => c.type === 'text').map(c => c.text).join('\n') || '';
+
+    logRequest({
+      endpoint: '/v1/messages (Anthropic)',
+      agent: youParams.agent,
+      model,
+      stream,
+      conversationId,
+      messageCount: messages.length,
+      input: currentInput
+    });
+
+    // Store user message
+    if (conversationId) {
+      const lastUserMsg = messages.filter(m => m.role === 'user').pop();
+      if (lastUserMsg) {
+        const content = typeof lastUserMsg.content === 'string' 
+          ? lastUserMsg.content 
+          : lastUserMsg.content.filter(c => c.type === 'text').map(c => c.text).join('\n');
+        addMessageToConversation(conversationId, 'user', content);
+      }
+    }
+
+    if (stream) {
+      // Streaming response
+      res.setHeader('Content-Type', 'text/event-stream');
+      res.setHeader('Cache-Control', 'no-cache');
+      res.setHeader('Connection', 'keep-alive');
+
+      // Send message_start with conversation_id
+      res.write(createMessageStartEvent(model, conversationId));
+      
+      // Send content_block_start
+      res.write(createContentBlockStartEvent(0));
+
+      try {
+        const response = await callYouApi(apiKey, { ...youParams, stream: true });
+        
+        let fullContent = '';
+        let buffer = '';
+
+        // Use Web Streams API (ReadableStream)
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+
+        const processStream = async () => {
+          try {
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+
+              buffer += decoder.decode(value, { stream: true });
+              const lines = buffer.split('\n');
+              buffer = lines.pop() || '';
+
+              for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                  const data = line.slice(6);
+                  if (data === '[DONE]') continue;
+                  
+                  try {
+                    const parsed = JSON.parse(data);
+                    
+                    // Handle streaming delta format
+                    if (parsed.type === 'response.output_text.delta' && 
+                        parsed.response?.type === 'message.answer' && 
+                        parsed.response?.delta) {
+                      const newText = parsed.response.delta;
+                      if (newText) {
+                        fullContent += newText;
+                        res.write(createContentBlockDeltaEvent(newText, 0));
+                      }
+                    }
+                    
+                    // Also handle full output format (non-streaming fallback)
+                    if (parsed.output) {
+                      for (const item of parsed.output) {
+                        if (item.type === 'message.answer' && item.text) {
+                          const newText = item.text.slice(fullContent.length);
+                          if (newText) {
+                            fullContent = item.text;
+                            res.write(createContentBlockDeltaEvent(newText, 0));
+                          }
+                        }
+                      }
+                    }
+                  } catch (e) {
+                    // Skip invalid JSON
+                  }
+                }
+              }
+            }
+
+            // Store assistant response
+            if (conversationId && fullContent) {
+              addMessageToConversation(conversationId, 'assistant', fullContent);
+            }
+
+            logStreamComplete({
+              conversationId,
+              contentLength: fullContent.length,
+              messageCount: messages.length + 1,
+              agent: youParams.agent,
+              stream: true,
+              responsePreview: fullContent
+            });
+
+            // Send closing events
+            res.write(createContentBlockStopEvent(0));
+            res.write(createMessageDeltaEvent(Math.floor(fullContent.length / 4)));
+            res.write(createMessageStopEvent());
+            res.end();
+          } catch (error) {
+            console.error('Stream processing error:', error);
+            res.write(createContentBlockDeltaEvent(`Error: ${error.message}`, 0));
+            res.write(createContentBlockStopEvent(0));
+            res.write(createMessageDeltaEvent(0));
+            res.write(createMessageStopEvent());
+            res.end();
+          }
+        };
+
+        processStream();
+
+      } catch (error) {
+        console.error('Streaming error:', error);
+        res.write(createContentBlockDeltaEvent(`Error: ${error.message}`, 0));
+        res.write(createContentBlockStopEvent(0));
+        res.write(createMessageDeltaEvent(0));
+        res.write(createMessageStopEvent());
+        res.end();
+      }
+
+    } else {
+      // Non-streaming response
+      const response = await callYouApi(apiKey, youParams);
+      const data = await response.json();
+      
+      console.log('📥 You.com response received');
+      
+      const anthropicResponse = convertToAnthropicResponse(data, model);
+      
+      // Store assistant response
+      if (conversationId) {
+        const content = anthropicResponse.content[0]?.text || '';
+        if (content) {
+          addMessageToConversation(conversationId, 'assistant', content);
+        }
+        // Add conversation_id to response
+        anthropicResponse.metadata = { conversation_id: conversationId };
+      }
+
+      res.json(anthropicResponse);
+    }
+
+  } catch (error) {
+    console.error('Anthropic messages error:', error);
+    res.status(500).json({
+      type: 'error',
+      error: {
+        type: 'api_error',
+        message: error.message
+      }
+    });
+  }
+});
+
+export default router;

package/lib/routes/chat.js

@@ -5,13 +5,13 @@
 import { Router } from 'express';
 import { authenticate } from '../auth-middleware.js';
 import { mapOpenAIToYouParams, convertToOpenAIResponse, createStreamChunk } from '../openai-mapper.js';
-import { callYouApi, extractText } from '../api-client.js';
+import { callYouApi } from '../api-client.js';
 import { 
   getConversation, 
-  createConversation, 
   addMessageToConversation,
   generateConversationId 
 } from '../conversation-store.js';
+import { logRequest, logStreamComplete } from '../request-logger.js';
 
 const router = Router();
 const API_KEY = process.env.YDC_API_KEY;
@@ -69,8 +69,19 @@ router.post('/v1/chat/completions', authenticate, async (req, res) => {
 
     const youParams = mapOpenAIToYouParams({ ...req.body, messages: fullMessages });
     
-    console.log('📤 Sending request to You.com:', JSON.stringify({ ...youParams, input: youParams.input.substring(0, 200) + '...' }, null, 2));
-    console.log(`💬 Conversation ID: ${conversationId}, Messages: ${fullMessages.length}`);
+    // Get current user input for logging
+    const currentUserMsg = fullMessages.filter(m => m.role === 'user').pop();
+    const currentInput = currentUserMsg?.content || '';
+    
+    logRequest({
+      endpoint: '/v1/chat/completions (OpenAI)',
+      agent: youParams.agent,
+      model: req.body.model,
+      stream: req.body.stream || false,
+      conversationId,
+      messageCount: fullMessages.length,
+      input: currentInput
+    });
 
     const timeoutMs = youParams.timeout || (youParams.agent === 'advanced' ? 3000000 : 300000);
 
@@ -120,7 +131,9 @@ async function handleStreamingResponse(req, res, response, youParams, conversati
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = '';
+  let fullContent = '';
   const model = req.body.model || 'advanced';
+  const messageCount = req.body.messages?.length || 0;
   const STREAM_TIMEOUT = youParams.timeout || (youParams.agent === 'advanced' ? 3000000 : 300000);
 
   try {
@@ -159,6 +172,7 @@ async function handleStreamingResponse(req, res, response, youParams, conversati
                 res.end();
               }, STREAM_TIMEOUT);
 
+              fullContent += data.response.delta;
               const chunk = createStreamChunk(model, data.response.delta);
               res.write(`data: ${JSON.stringify(chunk)}\n\n`);
             }
@@ -170,6 +184,22 @@ async function handleStreamingResponse(req, res, response, youParams, conversati
     }
     
     clearTimeout(streamTimeout);
+    
+    // Store assistant response
+    if (conversationId && fullContent) {
+      addMessageToConversation(conversationId, 'assistant', fullContent);
+    }
+    
+    // Log completion
+    logStreamComplete({
+      conversationId,
+      contentLength: fullContent.length,
+      messageCount: messageCount + 1,
+      agent: youParams.agent,
+      stream: true,
+      responsePreview: fullContent
+    });
+    
   } catch (streamError) {
     console.error('❌ Streaming error:', streamError);
     res.write(`data: {"error": "Streaming error: ${streamError.message}"}\n\n`);

package/openai-server.js

@@ -15,9 +15,10 @@ import chatRoutes from './lib/routes/chat.js';
 import modelsRoutes from './lib/routes/models.js';
 import conversationsRoutes from './lib/routes/conversations.js';
 import healthRoutes from './lib/routes/health.js';
+import anthropicRoutes from './lib/routes/anthropic-messages.js';
 
 // Import config
-import { storeConfig } from './lib/conversation-store.js';
+import { storeConfig, initDatabase } from './lib/conversation-store.js';
 import { authConfig } from './lib/auth-middleware.js';
 import { listAdvancedVersions, getDefaultAdvancedVersion } from './lib/advanced-versions.js';
 
@@ -56,10 +57,14 @@ app.use(chatRoutes);
 app.use(modelsRoutes);
 app.use(conversationsRoutes);
 app.use(healthRoutes);
+app.use(anthropicRoutes);
 
 // Start server with auto port detection
 async function startServer() {
   try {
+    // Initialize database (handles missing better-sqlite3 gracefully)
+    await initDatabase();
+    
     const port = await findAvailablePort(startPort);
     app.set('port', port);
     
@@ -70,7 +75,8 @@ async function startServer() {
       console.log(`📦 Conversation Store: ${storeConfig.STORE_TYPE}${storeConfig.STORE_TYPE === 'sqlite' && storeConfig.isDbConnected() ? ` (${storeConfig.DB_PATH})` : ''}`);
       console.log(`🔐 Token Auth: ${authConfig.REQUIRE_TOKEN_AUTH ? `enabled (${authConfig.ACCESS_TOKENS_COUNT} tokens)` : 'disabled (accept all)'}`);
       console.log(`\n📖 Endpoints:`);
-      console.log(`   POST http://localhost:${port}/v1/chat/completions`);
+      console.log(`   POST http://localhost:${port}/v1/chat/completions  (OpenAI)`);
+      console.log(`   POST http://localhost:${port}/v1/messages          (Anthropic/Claude)`);
       console.log(`   GET  http://localhost:${port}/v1/models`);
       console.log(`   GET  http://localhost:${port}/v1/versions`);
       console.log(`   GET  http://localhost:${port}/health`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ydc-mcp-server",
-  "version": "1.6.1",
-  "description": "MCP server for You.com Agents API - Express, Research, Advanced agents with multi-turn conversations, streaming, and OpenAI compatibility",
+  "version": "1.7.8",
+  "description": "MCP server for You.com Agents API - Express, Research, Advanced agents with multi-turn conversations, streaming, OpenAI and Anthropic/Claude API compatibility",
   "type": "module",
   "main": "index.js",
   "bin": {
@@ -27,10 +27,10 @@
     "prepublishOnly": "echo 'Ready to publish'"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1"
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "sql.js": "^1.11.0"
   },
   "optionalDependencies": {
-    "better-sqlite3": "^11.7.0",
     "chalk": "^5.6.2",
     "cli-progress": "^3.12.0",
     "cli-table3": "^0.6.5",