ydc-mcp-server 1.7.0 → 1.7.8

package/lib/anthropic-mapper.js

@@ -165,22 +165,29 @@ export function createAnthropicStreamEvent(eventType, data) {
 /**
  * Create message_start event
  */
-export function createMessageStartEvent(model) {
+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: {
-      id: `msg_${Date.now()}`,
-      type: 'message',
-      role: 'assistant',
-      content: [],
-      model: model,
-      stop_reason: null,
-      stop_sequence: null,
-      usage: {
-        input_tokens: 0,
-        output_tokens: 0
-      }
-    }
+    message
   });
 }
 

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

@@ -4,7 +4,7 @@
  */
 
 import { Router } from 'express';
-import { callYouApi, extractText } from '../api-client.js';
+import { callYouApi } from '../api-client.js';
 import { 
   mapAnthropicToYouParams, 
   convertToAnthropicResponse,
@@ -19,8 +19,9 @@ import {
   getConversation,
   createConversation,
   addMessageToConversation,
-  generateConversationId 
+  generateConversationId
 } from '../conversation-store.js';
+import { logRequest, logStreamComplete, logResponse } from '../request-logger.js';
 
 const router = Router();
 
@@ -56,13 +57,11 @@ router.post('/v1/messages', async (req, res) => {
 
     const apiKey = getApiKey();
     
-    // Handle conversation persistence via metadata
-    let conversationId = metadata?.conversation_id;
-    if (conversationId) {
-      const existingConv = getConversation(conversationId);
-      if (!existingConv) {
-        createConversation(conversationId);
-      }
+    // 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
@@ -75,6 +74,22 @@ router.post('/v1/messages', async (req, res) => {
       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();
@@ -92,8 +107,8 @@ router.post('/v1/messages', async (req, res) => {
       res.setHeader('Cache-Control', 'no-cache');
       res.setHeader('Connection', 'keep-alive');
 
-      // Send message_start
-      res.write(createMessageStartEvent(model));
+      // Send message_start with conversation_id
+      res.write(createMessageStartEvent(model, conversationId));
       
       // Send content_block_start
       res.write(createContentBlockStartEvent(0));
@@ -104,53 +119,88 @@ router.post('/v1/messages', async (req, res) => {
         let fullContent = '';
         let buffer = '';
 
-        response.body.on('data', (chunk) => {
-          buffer += chunk.toString();
-          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);
-                if (parsed.output) {
-                  for (const item of parsed.output) {
-                    if (item.type === 'message.answer' && item.text) {
-                      const newText = item.text.slice(fullContent.length);
+        // 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 = item.text;
+                        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
                   }
                 }
-              } catch (e) {
-                // Skip invalid JSON
               }
             }
-          }
-        });
 
-        response.body.on('end', () => {
-          // Store assistant response
-          if (conversationId && fullContent) {
-            addMessageToConversation(conversationId, 'assistant', fullContent);
-          }
+            // Store assistant response
+            if (conversationId && fullContent) {
+              addMessageToConversation(conversationId, 'assistant', fullContent);
+            }
 
-          // Send closing events
-          res.write(createContentBlockStopEvent(0));
-          res.write(createMessageDeltaEvent(Math.floor(fullContent.length / 4)));
-          res.write(createMessageStopEvent());
-          res.end();
-        });
+            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();
+          }
+        };
 
-        response.body.on('error', (error) => {
-          console.error('Stream error:', error);
-          res.end();
-        });
+        processStream();
 
       } catch (error) {
         console.error('Streaming error:', error);
@@ -166,6 +216,8 @@ router.post('/v1/messages', async (req, res) => {
       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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydc-mcp-server",
-  "version": "1.7.0",
+  "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",