ydc-mcp-server 1.7.0 → 1.7.10

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,115 @@
+/**
+ * Request Logger Module
+ * Pretty prints request/response info using cli-table3
+ */
+
+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
+}
+
+// Track last request ID for comparison
+let lastRequestId = null;
+
+// Helper to create table
+function createTable() {
+  return new Table({
+    colWidths: [4, 12, 60],
+    wordWrap: true,
+    chars: {
+      'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+      'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+      'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+      'right': '│', 'right-mid': '┤', 'middle': '│'
+    }
+  });
+}
+
+// Helper to print history
+function printHistory(history, label) {
+  if (history.length === 0) return;
+  
+  if (tableAvailable) {
+    const table = createTable();
+    history.forEach((item, index) => {
+      const content = item.content || '';
+      const preview = content.length > 80 ? content.substring(0, 80) + '...' : content;
+      table.push([index + 1, item.role, preview]);
+    });
+    console.log(`   ${label}:`);
+    console.log(table.toString());
+  } else {
+    console.log(`   ${label}:`);
+    history.forEach((item, index) => {
+      const content = item.content || '';
+      const preview = content.length > 50 ? content.substring(0, 50) + '...' : content;
+      console.log(`   ${index + 1}. [${item.role}] ${preview}`);
+    });
+  }
+}
+
+/**
+ * Log request with history
+ */
+export function logRequest(info) {
+  const { 
+    conversationId, 
+    agent = 'unknown',
+    stream = false,
+    messageCount = 0,
+    inputMessages = []
+  } = info;
+  
+  const shortId = conversationId ? conversationId.split('-')[0] : 'new';
+  lastRequestId = shortId;
+  const streamMode = stream ? 'stream' : 'sync';
+  
+  console.log(`📤 Request: ${shortId}, Messages: ${messageCount}`);
+  console.log(`   ${agent}(${streamMode})`);
+  
+  printHistory(inputMessages, 'History');
+}
+
+/**
+ * Log stream complete with history
+ */
+export function logStreamComplete(info) {
+  const {
+    conversationId,
+    contentLength = 0,
+    messageCount = 0,
+    agent = 'unknown',
+    stream = true,
+    inputMessages = []
+  } = info;
+
+  const streamMode = stream ? 'stream' : 'sync';
+  const shortId = conversationId ? conversationId.split('-')[0] : 'new';
+  
+  // 如果 Complete ID 和 Request ID 不同，顯示括號
+  let idDisplay;
+  if (lastRequestId && lastRequestId !== shortId) {
+    idDisplay = `(${shortId})`;
+  } else {
+    idDisplay = shortId;
+  }
+  
+  console.log(`📥 Complete: ${idDisplay}, ${contentLength} chars, Messages: ${messageCount}`);
+  console.log(`   ${agent}(${streamMode})`);
+  
+  printHistory(inputMessages, 'History');
+  console.log('');
+}
+
+/**
+ * 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,35 @@ 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') || '';
+
+    // 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();
@@ -92,8 +120,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 +132,89 @@ 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: fullMessages.length + 1,
+              agent: youParams.agent,
+              stream: true,
+              responsePreview: fullContent,
+              inputMessages: [...fullMessages, { role: 'assistant', content: fullContent }]
+            });
 
-        response.body.on('error', (error) => {
-          console.error('Stream error:', error);
-          res.end();
-        });
+            // 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);
@@ -166,18 +230,27 @@ 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
-      if (conversationId) {
-        const content = anthropicResponse.content[0]?.text || '';
-        if (content) {
-          addMessageToConversation(conversationId, 'assistant', content);
-        }
+      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);
     }
 

package/lib/routes/chat.js

@@ -5,19 +5,27 @@
 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;
 
 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: {
@@ -69,17 +77,29 @@ 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,
+      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);
+      await handleStreamingResponse(req, res, response, youParams, conversationId, fullMessages);
     } else {
       const response = await callYouApi(API_KEY, youParams, { timeout: timeoutMs });
-      await handleNonStreamingResponse(req, res, response, conversationId);
+      await handleNonStreamingResponse(req, res, response, conversationId, fullMessages);
     }
 
   } catch (error) {
@@ -105,7 +125,7 @@ router.post('/v1/chat/completions', authenticate, async (req, res) => {
   }
 });
 
-async function handleStreamingResponse(req, res, response, youParams, conversationId) {
+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');
@@ -120,7 +140,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 +181,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 +193,23 @@ 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,
+      inputMessages: inputMessages
+    });
+    
   } catch (streamError) {
     console.error('❌ Streaming error:', streamError);
     res.write(`data: {"error": "Streaming error: ${streamError.message}"}\n\n`);
@@ -181,7 +221,7 @@ async function handleStreamingResponse(req, res, response, youParams, conversati
   }
 }
 
-async function handleNonStreamingResponse(req, res, response, conversationId) {
+async function handleNonStreamingResponse(req, res, response, conversationId, inputMessages = []) {
   const data = await response.json();
   console.log('📥 You.com response:', JSON.stringify(data, null, 2));
   
@@ -192,6 +232,16 @@ async function handleNonStreamingResponse(req, res, response, 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);
 }

package/package.json

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