llmjs2 1.3.2 → 1.3.3

package/README.md

@@ -392,6 +392,69 @@ Run the test suite:
 npm test
 ```
 
+Test basic completion functionality:
+
+```bash
+npm run test:completion
+```
+
+## Logging
+
+Configure logging levels for LLM provider requests and responses:
+
+```bash
+# Show all logs (DEBUG, WARN, INFO, ERROR)
+LLMJS2_LOG=debug node your-script.js
+
+# Show INFO and ERROR logs only
+LLMJS2_LOG=info node your-script.js
+
+# Show WARN, INFO, and ERROR logs
+LLMJS2_LOG=warn node your-script.js
+
+# Show ERROR logs only
+LLMJS2_LOG=error node your-script.js
+
+# Examples
+LLMJS2_LOG=debug npm run chat
+LLMJS2_LOG=info npm run test:completion
+```
+
+### Log Levels
+
+- **DEBUG**: All logs including detailed request/response data
+- **INFO**: LLM provider communication and important events
+- **WARN**: Warnings and important notifications
+- **ERROR**: Errors and failures
+
+### Log Format
+
+```
+[TIMESTAMP] [LEVEL] MESSAGE
+DATA_OBJECT (JSON formatted)
+```
+
+### Example Output
+
+```
+[2026-04-13T10:14:58.123Z] [INFO] LLMJS2 📤 Sending to LLM provider
+{
+  "source": "completion",
+  "provider": "ollama",
+  "model": "minimax-m2.5:cloud",
+  "apiKey": "2620e31dea...",
+  "messages": [{"role": "user", "content": "Hello!"}]
+}
+
+[2026-04-13T10:15:01.456Z] [INFO] LLMJS2 📥 Received from LLM provider
+{
+  "source": "completion",
+  "content": "Hello! How can I help you?",
+  "role": "assistant",
+  "usage": {"prompt_eval_count": 10, "eval_count": 15}
+}
+```
+
 ## License
 
 MIT

package/index.js

@@ -3,6 +3,7 @@ const OllamaProvider = require('./providers/ollama');
 const OpenRouterProvider = require('./providers/openrouter');
 const { router } = require('./router');
 const { app } = require('./server');
+const logger = require('./logger');
 
 class LLMJS2 {
   constructor(config = {}) {
@@ -166,8 +167,25 @@ class LLMJS2 {
         provider.timeout = options.timeout;
       }
 
+      // Log request information
+      const apiKeyPreview = provider.apiKey ? provider.apiKey.substring(0, 10) + '...' : 'none';
+      logger.info('LLMJS2 📤 Sending to LLM provider', {
+        source: 'completion',
+        provider: provider.constructor.name.replace('Provider', '').toLowerCase(),
+        model: finalModel,
+        apiKey: apiKeyPreview,
+        messages: messages,
+        options: { ...options, model: finalModel }
+      });
+
       const result = await provider.createCompletion(messages, { ...options, model: finalModel });
 
+      // Log response information
+      logger.info('LLMJS2 📥 Received from LLM provider', {
+        source: 'completion',
+        ...result
+      });
+
       return result.content;
 
     } catch (error) {

package/logger.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * Simple logging utility for llmjs2
+ * Provides structured logging with timestamps and levels
+ */
+
+class Logger {
+  constructor() {
+    this.levels = {
+      DEBUG: 0,  // Shows all logs
+      INFO: 1,   // Shows INFO and ERROR only
+      WARN: 2,   // Shows WARN, INFO, and ERROR
+      ERROR: 3,  // Shows ERROR only
+      FATAL: 4
+    };
+
+    // Set level based on LLMJS2_LOG environment variable
+    this.setLevelFromEnv();
+  }
+
+  setLevelFromEnv() {
+    const envLevel = process.env.LLMJS2_LOG;
+    if (!envLevel) {
+      // Default to no logging if not set
+      this.currentLevel = 99; // Higher than any level
+      return;
+    }
+
+    const upperEnvLevel = envLevel.toUpperCase();
+    if (this.levels[upperEnvLevel] !== undefined) {
+      this.currentLevel = this.levels[upperEnvLevel];
+    } else {
+      // Default to INFO if invalid value
+      this.currentLevel = this.levels.INFO;
+    }
+  }
+
+  setLevel(level) {
+    if (this.levels[level] !== undefined) {
+      this.currentLevel = this.levels[level];
+    }
+  }
+
+  formatMessage(level, message, data = null) {
+    const timestamp = new Date().toISOString();
+    let output = `[${timestamp}] [${level}] ${message}`;
+
+    if (data) {
+      output += '\n' + JSON.stringify(data, null, 2);
+    }
+
+    return output;
+  }
+
+  shouldLog(level) {
+    const levelValue = this.levels[level];
+
+    // No logging if not configured
+    if (this.currentLevel === 99) return false;
+
+    // Custom logic based on user's requirements
+    if (this.currentLevel === this.levels.DEBUG) {
+      // Debug shows all levels
+      return true;
+    } else if (this.currentLevel === this.levels.INFO) {
+      // Info shows INFO and ERROR only
+      return level === 'INFO' || level === 'ERROR';
+    } else if (this.currentLevel === this.levels.WARN) {
+      // Warn shows WARN, INFO, and ERROR
+      return level === 'WARN' || level === 'INFO' || level === 'ERROR';
+    } else if (this.currentLevel === this.levels.ERROR) {
+      // Error shows ERROR only
+      return level === 'ERROR';
+    }
+
+    return false;
+  }
+
+  debug(message, data = null) {
+    if (this.shouldLog('DEBUG')) {
+      console.log(this.formatMessage('DEBUG', message, data));
+    }
+  }
+
+  info(message, data = null) {
+    if (this.shouldLog('INFO')) {
+      console.log(this.formatMessage('INFO', message, data));
+    }
+  }
+
+  warn(message, data = null) {
+    if (this.shouldLog('WARN')) {
+      console.warn(this.formatMessage('WARN', message, data));
+    }
+  }
+
+  error(message, data = null) {
+    if (this.shouldLog('ERROR')) {
+      console.error(this.formatMessage('ERROR', message, data));
+    }
+  }
+
+  fatal(message, data = null) {
+    if (this.shouldLog('FATAL')) {
+      console.error(this.formatMessage('FATAL', message, data));
+    }
+  }
+}
+
+// Create singleton logger instance
+const logger = new Logger();
+
+// Export for use in other modules
+module.exports = logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llmjs2",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "A unified Node.js library for connecting to multiple LLM providers: OpenAI, Ollama, and OpenRouter",
   "main": "index.js",
   "type": "commonjs",
@@ -10,6 +10,7 @@
     "server": "node cli.js",
     "router:example": "node server-config.js",
     "chat": "node chat-app.js",
+    "test:completion": "node test-completion.js",
     "lint": "echo 'No linting configured'",
     "typecheck": "echo 'No TypeScript configured'"
   },

package/router.js

@@ -1,6 +1,7 @@
 const OpenAIProvider = require('./providers/openai');
 const OllamaProvider = require('./providers/ollama');
 const OpenRouterProvider = require('./providers/openrouter');
+const logger = require('./logger');
 
 class Router {
   constructor(modelList, strategy = 'default') {
@@ -180,7 +181,7 @@ class Router {
       };
 
     } catch (error) {
-      console.error(`[${processId}] Router error:`, error.message);
+      logger.error(`Router error`, { processId, error: error.message });
       throw error;
     }
   }
@@ -200,8 +201,8 @@ class Router {
       provider.apiKey = modelConfig.llm_params.api_key;
     }
 
-    // Call the provider directly with just the actual model name (without provider prefix)
-    return await provider.createCompletion(input.messages, {
+    // Prepare the completion options
+    const completionOptions = {
       model: actualModel,
       temperature: input.temperature,
       maxTokens: input.maxTokens,
@@ -211,7 +212,29 @@ class Router {
       stop: input.stop,
       tools: input.tools,
       toolChoice: input.toolChoice
+    };
+
+    // Log request information
+    const apiKeyPreview = provider.apiKey ? provider.apiKey.substring(0, 10) + '...' : 'none';
+    logger.info('LLMJS2 📤 Sending to LLM provider', {
+      source: 'router',
+      provider: providerName,
+      model: actualModel,
+      apiKey: apiKeyPreview,
+      messages: input.messages,
+      options: completionOptions
     });
+
+    // Call the provider directly with just the actual model name (without provider prefix)
+    const result = await provider.createCompletion(input.messages, completionOptions);
+
+    // Log response information
+    logger.info('LLMJS2 📥 Received from LLM provider', {
+      source: 'router',
+      ...result
+    });
+
+    return result;
   }
 
   generateProcessId() {

package/server.js

@@ -51,9 +51,12 @@ class Server {
         return;
       }
 
-      console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
-      console.log('Headers:', JSON.stringify(req.headers));
-      console.log('Body parsing completed successfully');
+      logger.debug('Incoming request', {
+        method: req.method,
+        url: req.url,
+        headers: req.headers,
+        bodyLength: JSON.stringify(body).length
+      });
 
       // Process the completion request
       const result = await this.processCompletion(body);
@@ -62,7 +65,7 @@ class Server {
       this.sendSuccess(res, result);
 
     } catch (error) {
-      console.error('Server error:', error);
+      logger.error('Server error', { error: error.message, url: req.url, method: req.method });
       this.sendError(res, 500, 'Internal Server Error', error.message);
     }
   }
@@ -114,7 +117,10 @@ class Server {
       throw new Error('No router configured. Use app.use(router) to add a router.');
     }
 
-    console.log(`Starting completion with model: ${body.model || 'auto-selected'}`);
+    logger.debug('Server processing completion request', {
+      model: body.model || 'auto-selected',
+      messageCount: body.messages?.length || 0
+    });
 
     const routerResponse = await this.router.completion(body);
     const { result, selectedModel, selectedModelName } = routerResponse;
@@ -168,6 +174,7 @@ class Server {
     const server = http.createServer((req, res) => this.handleRequest(req, res));
 
     server.listen(actualPort, actualHost, () => {
+      logger.info('Server started', { host: actualHost, port: actualPort });
       console.log(`🚀 llmjs2 server running on http://${actualHost}:${actualPort}`);
       if (callback) callback();
     });

package/test-completion.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * Simple Completion Test
+ * Tests basic llmjs2 completion functionality using defaults
+ */
+
+const { completion } = require('./index');
+
+async function testSimpleCompletion() {
+  console.log('🧪 Testing simple completion with defaults...\n');
+
+  try {
+    console.log('📤 Sending completion request...');
+    console.log('Prompt: "Hello! Can you tell me a short joke?"\n');
+
+    // Simple completion call - no model or API key specified
+    const response = await completion('Hello! Can you tell me a short joke?');
+
+    console.log('✅ Completion successful!');
+    console.log('📥 Response received:');
+    console.log('---');
+    console.log(response);
+    console.log('---\n');
+
+    // Basic validation
+    if (typeof response === 'string' && response.length > 0) {
+      console.log('✅ Response is valid string');
+      console.log(`📏 Response length: ${response.length} characters`);
+    } else {
+      console.log('❌ Response is not a valid string');
+      return false;
+    }
+
+    // Check if it looks like a joke or response
+    const hasJokeIndicators = response.toLowerCase().includes('joke') ||
+                            response.toLowerCase().includes('knock knock') ||
+                            response.includes('?') ||
+                            response.includes('!');
+
+    if (hasJokeIndicators) {
+      console.log('✅ Response appears to be joke-related');
+    } else {
+      console.log('ℹ️  Response received (may not be joke-related)');
+    }
+
+    console.log('\n🎉 Simple completion test passed!');
+    return true;
+
+  } catch (error) {
+    console.error('❌ Completion test failed:');
+    console.error('Error:', error.message);
+
+    if (error.message.includes('API key')) {
+      console.log('\n💡 Tip: Make sure you have API keys set in environment variables:');
+      console.log('   export OLLAMA_API_KEY=your_key');
+      console.log('   export OPEN_ROUTER_API_KEY=your_key');
+    }
+
+    return false;
+  }
+}
+
+// Check environment before running
+function checkEnvironment() {
+  const hasKeys = process.env.OLLAMA_API_KEY || process.env.OPEN_ROUTER_API_KEY;
+
+  if (!hasKeys) {
+    console.log('⚠️  No API keys found in environment variables.');
+    console.log('   Set at least one: OLLAMA_API_KEY or OPEN_ROUTER_API_KEY');
+    console.log('   The test will still run but may fail.\n');
+  } else {
+    console.log('✅ API keys found in environment\n');
+  }
+}
+
+// Run the test
+async function main() {
+  console.log('🚀 Running Simple Completion Test for llmjs2\n');
+
+  checkEnvironment();
+
+  const success = await testSimpleCompletion();
+
+  if (success) {
+    console.log('\n✨ Test completed successfully!');
+    process.exit(0);
+  } else {
+    console.log('\n💥 Test failed!');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { testSimpleCompletion };