llmjs2 1.3.9 → 1.7.1

package/providers/openrouter.js

@@ -1,113 +0,0 @@
-const https = require('https');
-
-class OpenRouterProvider {
-  constructor(config = {}) {
-    this.baseURL = config.baseURL || process.env.OPEN_ROUTER_BASE_URL || 'https://openrouter.ai/api/v1/chat/completions';
-    this.apiKey = config.apiKey || process.env.OPEN_ROUTER_API_KEY;
-    this.defaultModel = config.defaultModel || process.env.OPEN_ROUTER_DEFAULT_MODEL || 'openrouter/free';
-    this.timeout = config.timeout || 60000; // 60 seconds
-    this.config = config; // Store entire config for additional properties like referer, title
-  }
-
-  async makeRequest(data) {
-    if (!this.apiKey) {
-      throw new Error('OpenRouter API key is required. Set OPEN_ROUTER_API_KEY environment variable or pass apiKey in config.');
-    }
-
-    const postData = JSON.stringify(data);
-
-    const parsedUrl = new URL(this.baseURL);
-
-    const options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port || 443,
-      path: parsedUrl.pathname + parsedUrl.search,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-        'Content-Length': Buffer.byteLength(postData),
-        'HTTP-Referer': this.config.referer || process.env.OPEN_ROUTER_REFERER || '',
-        'X-Title': this.config.title || process.env.OPEN_ROUTER_TITLE || ''
-      }
-    };
-
-    // Remove empty headers
-    if (!options.headers['HTTP-Referer']) delete options.headers['HTTP-Referer'];
-    if (!options.headers['X-Title']) delete options.headers['X-Title'];
-
-    return new Promise((resolve, reject) => {
-      const req = https.request(options, (res) => {
-        let body = '';
-
-        res.on('data', (chunk) => {
-          body += chunk;
-        });
-
-        res.on('end', () => {
-          try {
-            if (res.statusCode >= 200 && res.statusCode < 300) {
-              const response = JSON.parse(body);
-              resolve(response);
-            } else {
-              const error = JSON.parse(body);
-              reject(new Error(`OpenRouter API error (${res.statusCode}): ${error.error?.message || 'Unknown error'}`));
-            }
-          } catch (parseError) {
-            reject(new Error(`Failed to parse OpenRouter response: ${parseError.message}`));
-          }
-        });
-      });
-
-      req.on('error', (error) => {
-        reject(new Error(`OpenRouter request failed: ${error.message}`));
-      });
-
-      req.setTimeout(this.timeout, () => {
-        req.destroy();
-        reject(new Error('OpenRouter request timed out'));
-      });
-
-      req.write(postData);
-      req.end();
-    });
-  }
-
-  async createCompletion(messages, options = {}) {
-    const data = {
-      model: options.model || this.defaultModel,
-      messages: messages,
-      temperature: options.temperature || 0.7,
-      max_tokens: options.maxTokens,
-      top_p: options.topP,
-      frequency_penalty: options.frequencyPenalty,
-      presence_penalty: options.presencePenalty,
-      stop: options.stop,
-      tools: options.tools,
-      tool_choice: options.toolChoice,
-      transforms: options.transforms,
-      models: options.models,
-      route: options.route
-    };
-
-    // Remove undefined values
-    Object.keys(data).forEach(key => {
-      if (data[key] === undefined) {
-        delete data[key];
-      }
-    });
-
-    const response = await this.makeRequest(data);
-
-    return {
-      content: response.choices[0]?.message?.content || '',
-      role: response.choices[0]?.message?.role || 'assistant',
-      tool_calls: response.choices[0]?.message?.tool_calls,
-      usage: response.usage,
-      model: response.model,
-      finishReason: response.choices[0]?.finish_reason
-    };
-  }
-}
-
-module.exports = OpenRouterProvider;

package/router.js

@@ -1,273 +0,0 @@
-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') {
-    this.modelList = this.normalizeModelList(modelList);
-    this.strategy = strategy;
-    this.providers = {
-      openai: new OpenAIProvider(),
-      ollama: new OllamaProvider(),
-      openrouter: new OpenRouterProvider()
-    };
-    this.guardrails = [];
-    this.sequentialIndex = 0;
-
-    // Group models by model_name for load balancing
-    this.modelsByName = {};
-    this.modelList.forEach(model => {
-      if (!this.modelsByName[model.model_name]) {
-        this.modelsByName[model.model_name] = [];
-      }
-      this.modelsByName[model.model_name].push(model);
-    });
-  }
-
-  normalizeModelList(modelList) {
-    return modelList.map(model => ({
-      model_name: model.model_name,
-      llm_params: {
-        model: model.llm_params.model,
-        api_key: this.resolveApiKey(model.llm_params.api_key),
-        api_base: model.llm_params.api_base
-      }
-    }));
-  }
-
-  resolveApiKey(apiKey) {
-    if (typeof apiKey === 'string' && apiKey.startsWith('os.environ/')) {
-      const envVar = apiKey.replace('os.environ/', '');
-      return process.env[envVar] || apiKey;
-    }
-    return apiKey;
-  }
-
-  setGuardrails(guardrails) {
-    this.guardrails = guardrails || [];
-  }
-
-  selectModel(modelName) {
-    if (!modelName) {
-      // Auto-routing based on strategy
-      return this.autoSelectModel();
-    }
-
-    // Direct model selection with load balancing
-    const availableModels = this.modelsByName[modelName];
-    if (!availableModels || availableModels.length === 0) {
-      throw new Error(`Model '${modelName}' not found in router configuration`);
-    }
-
-    if (availableModels.length === 1) {
-      return availableModels[0];
-    }
-
-    // Load balancing for multiple models with same name
-    const randomIndex = Math.floor(Math.random() * availableModels.length);
-    return availableModels[randomIndex];
-  }
-
-  autoSelectModel() {
-    const allModels = this.modelList;
-
-    switch (this.strategy) {
-      case 'random':
-        const randomIndex = Math.floor(Math.random() * allModels.length);
-        return allModels[randomIndex];
-
-      case 'sequential':
-        const model = allModels[this.sequentialIndex];
-        this.sequentialIndex = (this.sequentialIndex + 1) % allModels.length;
-        return model;
-
-      case 'default':
-      default:
-        // Use sequential selection for auto-routing
-        const selectedModel = allModels[this.sequentialIndex];
-        this.sequentialIndex = (this.sequentialIndex + 1) % allModels.length;
-        return selectedModel;
-    }
-  }
-
-  async applyPreGuardrails(processId, input) {
-    let currentInput = input;
-
-    for (const guardrail of this.guardrails) {
-      if (guardrail.mode === 'pre_call') {
-        try {
-          const result = await this.executeGuardrail(guardrail, processId, currentInput);
-          if (result === null || result === undefined) {
-            throw new Error(`Guardrail '${guardrail.name}' returned null/undefined`);
-          }
-          currentInput = result;
-        } catch (error) {
-          throw new Error(`Pre-call guardrail '${guardrail.name}' failed: ${error.message}`);
-        }
-      }
-    }
-
-    return currentInput;
-  }
-
-  async applyPostGuardrails(processId, result) {
-    let currentResult = result;
-
-    for (const guardrail of this.guardrails) {
-      if (guardrail.mode === 'post_call') {
-        try {
-          const processed = await this.executeGuardrail(guardrail, processId, currentResult);
-          if (processed === null || processed === undefined) {
-            throw new Error(`Guardrail '${guardrail.name}' returned null/undefined`);
-          }
-          currentResult = processed;
-        } catch (error) {
-          throw new Error(`Post-call guardrail '${guardrail.name}' failed: ${error.message}`);
-        }
-      }
-    }
-
-    return currentResult;
-  }
-
-  async executeGuardrail(guardrail, processId, data) {
-    if (typeof guardrail.code === 'string') {
-      // Execute string code as function
-      const func = new Function('processId', 'data', `return (${guardrail.code})(processId, data)`);
-      return await func(processId, data);
-    } else if (typeof guardrail.code === 'function') {
-      return await guardrail.code(processId, data);
-    } else {
-      throw new Error(`Invalid guardrail code for '${guardrail.name}'`);
-    }
-  }
-
-  async completion(options) {
-    const processId = this.generateProcessId();
-    let selectedModel;
-
-    try {
-      // Select model
-      selectedModel = this.selectModel(options.model);
-      console.log(`[${processId}] Selected model: ${selectedModel.llm_params.model}`);
-
-      // Prepare input for guardrails
-      const input = {
-        model: selectedModel.llm_params.model,
-        messages: options.messages || [],
-        temperature: options.temperature,
-        maxTokens: options.max_tokens || options.maxTokens,
-        topP: options.top_p || options.topP,
-        frequencyPenalty: options.frequency_penalty || options.frequencyPenalty,
-        presencePenalty: options.presence_penalty || options.presencePenalty,
-        stop: options.stop,
-        tools: options.tools,
-        toolChoice: options.tool_choice || options.toolChoice
-      };
-
-      // Apply pre-call guardrails
-      const processedInput = await this.applyPreGuardrails(processId, input);
-
-      // Create completion using selected model
-      const result = await this.callProvider(selectedModel, processedInput);
-
-      // Apply post-call guardrails
-      const finalResult = await this.applyPostGuardrails(processId, result);
-
-      // Return result with selected model information
-      return {
-        result: finalResult,
-        selectedModel: selectedModel.llm_params.model, // Full model name with provider prefix
-        selectedModelName: selectedModel.model_name // User-friendly model name
-      };
-
-    } catch (error) {
-      logger.error(`Router error`, { processId, error: error.message });
-      throw error;
-    }
-  }
-
-  async callProvider(modelConfig, input) {
-    const firstSlashIndex = modelConfig.llm_params.model.indexOf('/');
-    const providerName = firstSlashIndex !== -1 ? modelConfig.llm_params.model.substring(0, firstSlashIndex) : '';
-    const actualModel = firstSlashIndex !== -1 ? modelConfig.llm_params.model.substring(firstSlashIndex + 1) : modelConfig.llm_params.model;
-    const provider = this.providers[providerName];
-
-    if (!provider) {
-      throw new Error(`Unknown provider: ${providerName}`);
-    }
-
-    // Set the API key for this request (only if provided, otherwise use provider's default)
-    if (modelConfig.llm_params.api_key !== undefined) {
-      provider.apiKey = modelConfig.llm_params.api_key;
-    }
-
-    // Prepare the completion options
-    const completionOptions = {
-      model: actualModel,
-      temperature: input.temperature,
-      maxTokens: input.maxTokens,
-      topP: input.topP,
-      frequencyPenalty: input.frequencyPenalty,
-      presencePenalty: input.presencePenalty,
-      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() {
-    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  // Method to add guardrails dynamically
-  addGuardrail(guardrail) {
-    this.guardrails.push(guardrail);
-  }
-
-  // Method to get available models
-  getAvailableModels() {
-    return Object.keys(this.modelsByName);
-  }
-
-  // Method to get model count for load balancing info
-  getModelStats() {
-    const stats = {};
-    Object.keys(this.modelsByName).forEach(modelName => {
-      stats[modelName] = this.modelsByName[modelName].length;
-    });
-    return stats;
-  }
-}
-
-function router(modelList, strategy = 'default') {
-  return new Router(modelList, strategy);
-}
-
-module.exports = {
-  Router,
-  router
-};

package/test-completion.js

@@ -1,99 +0,0 @@
-#!/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?"');
-    console.log('Note: No model specified - will auto-select provider based on available API keys\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 };