ydc-mcp-server 1.6.1

package/lib/openai-mapper.js

@@ -0,0 +1,215 @@
+/**
+ * OpenAI Parameter Mapper Module
+ * Maps OpenAI API parameters to You.com API parameters
+ */
+
+import { 
+  getAdvancedVersion, 
+  isAdvancedVersion, 
+  getDefaultAdvancedVersion,
+  adjustWorkflowSteps
+} from './advanced-versions.js';
+
+// Parse custom agents from env
+function getCustomAgents() {
+  const raw = process.env.YDC_CUSTOM_AGENTS || '';
+  if (!raw) return new Map();
+  
+  const map = new Map();
+  raw.split(',').forEach(entry => {
+    const trimmed = entry.trim();
+    if (!trimmed) return;
+    
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+      map.set(trimmed.substring(0, colonIndex), trimmed.substring(colonIndex + 1));
+    } else {
+      map.set(trimmed, trimmed);
+    }
+  });
+  return map;
+}
+
+/**
+ * Map OpenAI request parameters to You.com parameters
+ */
+export function mapOpenAIToYouParams(openaiRequest) {
+  const {
+    model = 'advanced-3.0-high',
+    messages,
+    temperature = 0.7,
+    max_tokens = 1000,
+    stream = false,
+    tools = []
+  } = openaiRequest;
+
+  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: /, '');
+  }
+
+  // Check if it's an advanced version model
+  if (isAdvancedVersion(model)) {
+    const versionConfig = getAdvancedVersion(model);
+    if (versionConfig) {
+      const adjustedSteps = adjustWorkflowSteps(versionConfig.max_workflow_steps, temperature);
+      
+      return {
+        agent: 'advanced',
+        input,
+        stream,
+        verbosity: versionConfig.verbosity,
+        tools: tools.length > 0 ? tools : versionConfig.tools,
+        workflow_config: {
+          max_workflow_steps: adjustedSteps
+        },
+        timeout: versionConfig.timeout
+      };
+    }
+  }
+
+  // Handle legacy models (express, research, advanced)
+  let agent = model;
+  let verbosity = 'medium';
+  let defaultTools = tools;
+  let timeout = 300000;
+
+  if (model === 'advanced') {
+    const defaultVersion = getDefaultAdvancedVersion(temperature);
+    const versionConfig = getAdvancedVersion(defaultVersion);
+    if (versionConfig) {
+      const adjustedSteps = adjustWorkflowSteps(versionConfig.max_workflow_steps, temperature);
+      return {
+        agent: 'advanced',
+        input,
+        stream,
+        verbosity: versionConfig.verbosity,
+        tools: tools.length > 0 ? tools : versionConfig.tools,
+        workflow_config: {
+          max_workflow_steps: adjustedSteps
+        },
+        timeout: versionConfig.timeout
+      };
+    }
+  }
+
+  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);
+
+  // Check if model is a known legacy type
+  const knownAgents = ['express', 'research', 'advanced'];
+  
+  // Check custom agents mapping
+  const customAgents = getCustomAgents();
+  if (customAgents.has(model)) {
+    return {
+      agent: customAgents.get(model),
+      input,
+      stream,
+      timeout: 300000
+    };
+  }
+  
+  if (!knownAgents.includes(agent)) {
+    // Treat unknown model as custom agent ID
+    return {
+      agent: model,
+      input,
+      stream,
+      timeout: 300000
+    };
+  }
+
+  if (agent === 'advanced') {
+    timeout = 3000000;
+    if (tools.length === 0) {
+      defaultTools = [
+        { type: 'research', search_effort: 'auto', report_verbosity: 'medium' },
+        { type: 'compute' }
+      ];
+    }
+  }
+
+  return {
+    agent,
+    input,
+    stream,
+    verbosity,
+    tools: defaultTools,
+    workflow_config: {
+      max_workflow_steps
+    },
+    timeout
+  };
+}
+
+/**
+ * Convert You.com response to OpenAI format
+ */
+export function convertToOpenAIResponse(youResponse, model) {
+  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';
+
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model: `you-${model}`,
+    choices: [{
+      index: 0,
+      message: {
+        role: 'assistant',
+        content: content
+      },
+      finish_reason: 'stop'
+    }],
+    usage: {
+      prompt_tokens: Math.floor(Math.random() * 100) + 50,
+      completion_tokens: Math.floor(content.length / 4),
+      total_tokens: Math.floor(Math.random() * 100) + 50 + Math.floor(content.length / 4)
+    }
+  };
+}
+
+/**
+ * Create streaming chunk in OpenAI format
+ */
+export function createStreamChunk(model, content, finishReason = null) {
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model: `you-${model}`,
+    choices: [{
+      index: 0,
+      delta: content ? { content } : {},
+      finish_reason: finishReason
+    }]
+  };
+}

package/lib/routes/chat.js

@@ -0,0 +1,199 @@
+/**
+ * Chat Completions Route
+ */
+
+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 { 
+  getConversation, 
+  createConversation, 
+  addMessageToConversation,
+  generateConversationId 
+} from '../conversation-store.js';
+
+const router = Router();
+const API_KEY = process.env.YDC_API_KEY;
+
+router.post('/v1/chat/completions', authenticate, async (req, res) => {
+  try {
+    if (!API_KEY) {
+      return res.status(500).json({
+        error: {
+          message: 'YDC_API_KEY not configured on server',
+          type: 'server_error',
+          code: 'missing_api_key'
+        }
+      });
+    }
+
+    const { conversation_id, messages } = req.body;
+    let conversationId = conversation_id;
+    let fullMessages = messages || [];
+    
+    if (conversationId) {
+      const existingConv = getConversation(conversationId);
+      if (existingConv && existingConv.messages.length > 0) {
+        const storedMessages = existingConv.messages.map(m => ({ role: m.role, content: m.content }));
+        const newUserMessages = fullMessages.filter(m => m.role === 'user');
+        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 = newUserMessages[newUserMessages.length - 1];
+        if (lastNewUserMsg) {
+          const alreadyExists = fullMessages.some(m => m.role === 'user' && m.content === lastNewUserMsg.content);
+          if (!alreadyExists) {
+            fullMessages.push(lastNewUserMsg);
+          }
+        }
+      }
+    } else {
+      conversationId = generateConversationId();
+    }
+    
+    const lastUserMsg = fullMessages.filter(m => m.role === 'user').pop();
+    if (lastUserMsg) {
+      addMessageToConversation(conversationId, 'user', lastUserMsg.content);
+    }
+    
+    const systemMsg = fullMessages.find(m => m.role === 'system');
+    if (systemMsg) {
+      const conv = getConversation(conversationId);
+      if (conv && !conv.messages.some(m => m.role === 'system')) {
+        conv.messages.unshift({ role: 'system', content: systemMsg.content, timestamp: Date.now() });
+      }
+    }
+
+    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}`);
+
+    const timeoutMs = youParams.timeout || (youParams.agent === 'advanced' ? 3000000 : 300000);
+
+    if (req.body.stream) {
+      const response = await callYouApi(API_KEY, { ...youParams, stream: true }, { timeout: timeoutMs });
+      await handleStreamingResponse(req, res, response, youParams, conversationId);
+    } else {
+      const response = await callYouApi(API_KEY, youParams, { timeout: timeoutMs });
+      await handleNonStreamingResponse(req, res, response, conversationId);
+    }
+
+  } catch (error) {
+    console.error('❌ Server error:', error);
+    
+    if (error.name === 'AbortError') {
+      return res.status(408).json({
+        error: {
+          message: 'Request timeout - Advanced agent responses may require extended processing time',
+          type: 'timeout_error',
+          code: 'request_timeout'
+        }
+      });
+    }
+    
+    res.status(500).json({
+      error: {
+        message: error.message,
+        type: 'server_error',
+        code: 'internal_error'
+      }
+    });
+  }
+});
+
+async function handleStreamingResponse(req, res, response, youParams, conversationId) {
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+
+  if (!response.body) {
+    res.write(`data: {"error": "No response body"}\n\n`);
+    res.end();
+    return;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  const model = req.body.model || 'advanced';
+  const STREAM_TIMEOUT = youParams.timeout || (youParams.agent === 'advanced' ? 3000000 : 300000);
+
+  try {
+    let streamTimeout = setTimeout(() => {
+      const chunk = createStreamChunk(model, `\n\n[Response timeout]`, 'length');
+      res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+      res.write('data: [DONE]\n\n');
+      res.end();
+    }, STREAM_TIMEOUT);
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        clearTimeout(streamTimeout);
+        break;
+      }
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          try {
+            const data = JSON.parse(line.slice(6));
+            
+            if (data.type === 'response.output_text.delta' && 
+                data.response?.type === 'message.answer' && 
+                data.response?.delta) {
+              
+              clearTimeout(streamTimeout);
+              streamTimeout = setTimeout(() => {
+                const chunk = createStreamChunk(model, `\n\n[Response timeout]`, 'length');
+                res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+                res.write('data: [DONE]\n\n');
+                res.end();
+              }, STREAM_TIMEOUT);
+
+              const chunk = createStreamChunk(model, data.response.delta);
+              res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+            }
+          } catch (e) {
+            console.error('❌ Error parsing streaming data:', e);
+          }
+        }
+      }
+    }
+    
+    clearTimeout(streamTimeout);
+  } catch (streamError) {
+    console.error('❌ Streaming error:', streamError);
+    res.write(`data: {"error": "Streaming error: ${streamError.message}"}\n\n`);
+  } finally {
+    const finalChunk = createStreamChunk(model, null, 'stop');
+    res.write(`data: ${JSON.stringify(finalChunk)}\n\n`);
+    res.write('data: [DONE]\n\n');
+    res.end();
+  }
+}
+
+async function handleNonStreamingResponse(req, res, response, conversationId) {
+  const data = await response.json();
+  console.log('📥 You.com response:', JSON.stringify(data, null, 2));
+  
+  const openaiResponse = convertToOpenAIResponse(data, req.body.model || 'advanced');
+  
+  const assistantContent = openaiResponse.choices?.[0]?.message?.content;
+  if (assistantContent && conversationId) {
+    addMessageToConversation(conversationId, 'assistant', assistantContent);
+  }
+  
+  openaiResponse.conversation_id = conversationId;
+  res.json(openaiResponse);
+}
+
+export default router;

package/lib/routes/conversations.js

@@ -0,0 +1,94 @@
+/**
+ * Conversations Route
+ */
+
+import { Router } from 'express';
+import { authenticate } from '../auth-middleware.js';
+import { 
+  getConversation, 
+  createConversation, 
+  addMessageToConversation,
+  listAllConversations,
+  deleteConversation,
+  clearAllConversations
+} from '../conversation-store.js';
+
+const router = Router();
+
+// List all conversations
+router.get('/v1/conversations', authenticate, (req, res) => {
+  const conversations = listAllConversations();
+  
+  res.json({
+    object: 'list',
+    data: conversations.sort((a, b) => new Date(b.updated_at) - new Date(a.updated_at)),
+    total: conversations.length
+  });
+});
+
+// Get single conversation
+router.get('/v1/conversations/:id', authenticate, (req, res) => {
+  const conv = getConversation(req.params.id);
+  if (!conv) {
+    return res.status(404).json({
+      error: {
+        message: 'Conversation not found',
+        type: 'not_found_error',
+        code: 'conversation_not_found'
+      }
+    });
+  }
+  
+  res.json({
+    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(),
+    metadata: conv.metadata
+  });
+});
+
+// Create new conversation
+router.post('/v1/conversations', authenticate, (req, res) => {
+  const { metadata = {}, system_message } = req.body;
+  const conv = createConversation(null, metadata);
+  
+  if (system_message) {
+    addMessageToConversation(conv.id, 'system', system_message);
+  }
+  
+  res.status(201).json({
+    id: conv.id,
+    created_at: new Date(conv.createdAt).toISOString(),
+    metadata: conv.metadata
+  });
+});
+
+// Delete conversation
+router.delete('/v1/conversations/:id', authenticate, (req, res) => {
+  const conv = getConversation(req.params.id);
+  if (!conv) {
+    return res.status(404).json({
+      error: {
+        message: 'Conversation not found',
+        type: 'not_found_error',
+        code: 'conversation_not_found'
+      }
+    });
+  }
+  
+  deleteConversation(req.params.id);
+  res.json({ deleted: true, id: req.params.id });
+});
+
+// Clear all conversations
+router.delete('/v1/conversations', authenticate, (req, res) => {
+  const count = clearAllConversations();
+  res.json({ deleted: true, count });
+});
+
+export default router;

package/lib/routes/health.js

@@ -0,0 +1,31 @@
+/**
+ * Health Check Route
+ */
+
+import { Router } from 'express';
+import { getConversationCount, storeConfig } from '../conversation-store.js';
+import { authConfig } from '../auth-middleware.js';
+
+const router = Router();
+const API_KEY = process.env.YDC_API_KEY;
+
+router.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    ydc_api_key_configured: !!API_KEY,
+    auth: {
+      token_auth_enabled: authConfig.REQUIRE_TOKEN_AUTH,
+      allowed_tokens_count: authConfig.ACCESS_TOKENS_COUNT
+    },
+    conversations: {
+      store_type: storeConfig.STORE_TYPE,
+      db_path: storeConfig.STORE_TYPE === 'sqlite' && storeConfig.isDbConnected() ? storeConfig.DB_PATH : null,
+      active: getConversationCount(),
+      max: storeConfig.MAX_CONVERSATIONS,
+      ttl_hours: storeConfig.CONVERSATION_TTL / (60 * 60 * 1000)
+    }
+  });
+});
+
+export default router;

package/lib/routes/models.js

@@ -0,0 +1,111 @@
+/**
+ * Models Route
+ */
+
+import { Router } from 'express';
+import { authenticate } from '../auth-middleware.js';
+import { listAdvancedVersions, getVersionInfo, getDefaultAdvancedVersion } from '../advanced-versions.js';
+
+const router = Router();
+
+// Parse custom agents from env
+function getCustomAgents() {
+  const raw = process.env.YDC_CUSTOM_AGENTS || '';
+  if (!raw) return [];
+  
+  return raw.split(',').map(entry => {
+    const trimmed = entry.trim();
+    if (!trimmed) return null;
+    
+    // Format: name:id or just id
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex > 0) {
+      return {
+        name: trimmed.substring(0, colonIndex),
+        id: trimmed.substring(colonIndex + 1)
+      };
+    }
+    return { name: trimmed, id: trimmed };
+  }).filter(Boolean);
+}
+
+router.get('/v1/models', authenticate, (req, res) => {
+  const baseModels = [
+    {
+      id: 'advanced',
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'you-com',
+      permission: [],
+      root: 'advanced',
+      parent: null
+    },
+    {
+      id: 'express',
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'you-com',
+      permission: [],
+      root: 'express',
+      parent: null
+    },
+    {
+      id: 'research',
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'you-com',
+      permission: [],
+      root: 'research',
+      parent: null
+    }
+  ];
+
+  // Add custom agents from env/CLI
+  const customAgents = getCustomAgents();
+  const customModels = customAgents.map(agent => ({
+    id: agent.name,
+    object: 'model',
+    created: Math.floor(Date.now() / 1000),
+    owned_by: 'you-com',
+    permission: [],
+    root: 'custom',
+    parent: null,
+    agent_id: agent.id,
+    description: `Custom agent${agent.name !== agent.id ? ` (${agent.id})` : ''}`
+  }));
+
+  const advancedVersionModels = listAdvancedVersions().map(version => {
+    const versionInfo = getVersionInfo(version);
+    return {
+      id: version,
+      object: 'model',
+      created: Math.floor(Date.now() / 1000),
+      owned_by: 'you-com',
+      permission: [],
+      root: 'advanced',
+      parent: 'advanced',
+      description: versionInfo.description,
+      tools: versionInfo.tools
+    };
+  });
+
+  res.json({
+    object: 'list',
+    data: [...baseModels, ...customModels, ...advancedVersionModels]
+  });
+});
+
+router.get('/v1/versions', authenticate, (req, res) => {
+  const versions = listAdvancedVersions().map(version => getVersionInfo(version));
+  res.json({
+    object: 'list',
+    data: versions,
+    default_version: getDefaultAdvancedVersion(),
+    temperature_mapping: {
+      "0.0-0.5": "Uses medium verbosity versions with reduced workflow steps",
+      "0.5-1.0": "Uses high verbosity versions with increased workflow steps"
+    }
+  });
+});
+
+export default router;