ydc-agent 1.0.0

package/lib/routes/anthropic-messages.js

@@ -0,0 +1,269 @@
+/**
+ * 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') || '';
+
+    // Build full messages for logging (including system prompt)
+    const fullMessages = [];
+    if (system) {
+      fullMessages.push({ role: 'system', content: system });
+    }
+    messages.forEach(m => {
+      const content = typeof m.content === 'string' 
+        ? m.content 
+        : m.content?.filter(c => c.type === 'text').map(c => c.text).join('\n') || '';
+      fullMessages.push({ role: m.role, content });
+    });
+
+    logRequest({
+      endpoint: '/v1/messages (Anthropic)',
+      agent: youParams.agent,
+      model,
+      stream,
+      conversationId,
+      messageCount: fullMessages.length,
+      input: currentInput,
+      inputMessages: fullMessages
+    });
+
+    // 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: fullMessages.length + 1,
+              agent: youParams.agent,
+              stream: true,
+              responsePreview: fullContent,
+              inputMessages: [...fullMessages, { role: 'assistant', content: 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
+      const assistantContent = anthropicResponse.content[0]?.text || '';
+      if (conversationId && assistantContent) {
+        addMessageToConversation(conversationId, 'assistant', assistantContent);
+        // Add conversation_id to response
+        anthropicResponse.metadata = { conversation_id: conversationId };
+      }
+
+      logStreamComplete({
+        conversationId,
+        contentLength: assistantContent.length,
+        messageCount: fullMessages.length + 1,
+        agent: youParams.agent,
+        stream: false,
+        inputMessages: [...fullMessages, { role: 'assistant', content: assistantContent }]
+      });
+
+      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

@@ -0,0 +1,249 @@
+/**
+ * Chat Completions Route
+ */
+
+import { Router } from 'express';
+import { authenticate } from '../auth-middleware.js';
+import { mapOpenAIToYouParams, convertToOpenAIResponse, createStreamChunk } from '../openai-mapper.js';
+import { callYouApi } from '../api-client.js';
+import { 
+  getConversation, 
+  addMessageToConversation,
+  generateConversationId 
+} from '../conversation-store.js';
+import { logRequest, logStreamComplete } from '../request-logger.js';
+
+const router = Router();
+const API_KEY = process.env.YDC_API_KEY;
+
+router.post('/v1/chat/completions', authenticate, async (req, res) => {
+  try {
+    // Debug: log raw request
+    console.log('📨 Raw request body:', JSON.stringify({
+      conversation_id: req.body.conversation_id,
+      model: req.body.model,
+      messages_count: req.body.messages?.length,
+      messages: req.body.messages?.map(m => ({ role: m.role, content: m.content?.substring(0, 50) }))
+    }, null, 2));
+    
+    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 });
+    
+    // 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,
+      inputMessages: fullMessages
+    });
+
+    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, fullMessages);
+    } else {
+      const response = await callYouApi(API_KEY, youParams, { timeout: timeoutMs });
+      await handleNonStreamingResponse(req, res, response, conversationId, fullMessages);
+    }
+
+  } 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, inputMessages = []) {
+  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 = '';
+  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 {
+    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);
+
+              fullContent += data.response.delta;
+              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);
+    
+    // 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,
+      inputMessages: inputMessages
+    });
+    
+  } 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, inputMessages = []) {
+  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);
+  }
+  
+  // Log completion
+  logStreamComplete({
+    conversationId,
+    contentLength: assistantContent?.length || 0,
+    messageCount: inputMessages.length + 1,
+    agent: req.body.model || 'advanced',
+    stream: false,
+    inputMessages: inputMessages
+  });
+  
+  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;