llmjs2 1.1.1 → 1.3.0

package/index.js

@@ -1,246 +1,199 @@
-import { ollamaCompletion } from './providers/ollama.js';
-import { openrouterCompletion } from './providers/openrouter.js';
-
-/**
- * Main completion function that routes to the appropriate provider
- * Supports three calling conventions:
- * 1. completion(prompt) or completion(model, prompt) - Simple API with auto-detection
- * 2. completion(model, prompt, apiKey) - Function-based API
- * 3. completion({ model, messages, apiKey, tools }) - Object-based API
- * 
- * @param {string|object} modelOrOptions - Model identifier, prompt, or options object
- * @param {string} [prompt] - The prompt to send (for function-based API)
- * @param {string} [apiKey] - Optional API key (falls back to environment variables)
- * @returns {Promise<string|object>} The completion result (string or object with tool calls)
- */
-export async function completion(modelOrOptions, prompt, apiKey) {
-  let model, messages, key, tools;
-
-  // Handle simple API: completion(prompt) or completion(model, prompt)
-  if (typeof modelOrOptions === 'string' && (prompt === undefined || typeof prompt === 'string')) {
-    let simplePrompt, simpleModel;
-    
-    // If only one argument, determine if it's a prompt or a model
-    if (prompt === undefined) {
-      const trimmedModel = modelOrOptions.trim();
-      // Check if it looks like a model (contains /)
-      if (trimmedModel.includes('/')) {
-        // Function API: completion(model) - missing prompt
-        throw new Error('Prompt parameter is required');
-      } else {
-        // Simple API: completion(prompt)
-        simplePrompt = trimmedModel;
-        simpleModel = null;
-      }
-    }
-    // If two arguments, first is model, second is prompt
-    else {
-      simpleModel = modelOrOptions.trim();
-      simplePrompt = prompt.trim();
-    }
-
-    if (!simplePrompt) {
-      throw new Error('Prompt parameter cannot be empty');
-    }
-
-    // Validate model if provided
-    if (simpleModel !== null && simpleModel !== undefined) {
-      const slashIndex = simpleModel.indexOf('/');
-      if (slashIndex === -1) {
-        throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-      }
-
-      const modelProvider = simpleModel.substring(0, slashIndex).trim();
-      const modelName = simpleModel.substring(slashIndex + 1).trim();
-
-      if (!modelProvider || !modelName) {
-        throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-      }
-
-      if (modelProvider !== 'ollama' && modelProvider !== 'openrouter') {
-        throw new Error(`Unsupported provider: ${modelProvider}. Supported providers: ollama, openrouter`);
-      }
-    }
-
-    messages = [
-      {
-        role: 'user',
-        content: simplePrompt
-      }
-    ];
-
-    // Determine which provider to use
-    let provider;
-    if (simpleModel) {
-      // If model is provided, use the provider from the model
-      const slashIndex = simpleModel.indexOf('/');
-      if (slashIndex === -1) {
-        throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-      }
-
-      const modelProvider = simpleModel.substring(0, slashIndex).trim();
-      const modelName = simpleModel.substring(slashIndex + 1).trim();
-
-      if (!modelProvider || !modelName) {
-        throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-      }
-
-      provider = modelProvider.toLowerCase();
-      model = modelName;
-      
-      // Use the API key from the model's provider (may be undefined)
-      if (provider === 'ollama') {
-        key = process.env.OLLAMA_API_KEY;
-      } else if (provider === 'openrouter') {
-        key = process.env.OPEN_ROUTER_API_KEY;
-      }
-    } else {
-      // No model provided - use default based on available keys
-      const hasOllamaKey = !!process.env.OLLAMA_API_KEY;
-      const hasOpenRouterKey = !!process.env.OPEN_ROUTER_API_KEY;
-
-      if (!hasOllamaKey && !hasOpenRouterKey) {
-        throw new Error('No API key found. Set OLLAMA_API_KEY or OPEN_ROUTER_API_KEY environment variable.');
-      }
-
-      if (hasOllamaKey && hasOpenRouterKey) {
-        // Randomly choose between Ollama and OpenRouter
-        provider = Math.random() < 0.5 ? 'ollama' : 'openrouter';
-      } else if (hasOllamaKey) {
-        provider = 'ollama';
-      } else {
-        provider = 'openrouter';
-      }
-
-      // Use default model for the provider
-      if (provider === 'ollama') {
-        model = process.env.OLLAMA_DEFAULT_MODEL || 'minimax-m2.5:cloud';
-        key = process.env.OLLAMA_API_KEY;
-      } else {
-        model = process.env.OPEN_ROUTER_DEFAULT_MODEL || 'openrouter/free';
-        key = process.env.OPEN_ROUTER_API_KEY;
-      }
-    }
-
-    // Call the appropriate provider
-    if (provider === 'ollama') {
-      return ollamaCompletion(model, messages, key);
-    } else {
-      return openrouterCompletion(model, messages, key);
-    }
-  }
-
-  // Handle object-based API
-  if (typeof modelOrOptions === 'object' && modelOrOptions !== null) {
-    const options = modelOrOptions;
-    model = options.model;
-    messages = options.messages;
-    key = options.apiKey;
-    tools = options.tools;
-
-    if (!model || typeof model !== 'string') {
-      throw new Error('Model parameter is required and must be a string');
-    }
-
-    if (!messages || !Array.isArray(messages) || messages.length === 0) {
-      throw new Error('Messages parameter is required and must be a non-empty array');
-    }
-
-    // Validate messages format
-    for (const msg of messages) {
-      if (!msg.role) {
-        throw new Error('Each message must have a "role" property');
-      }
-      
-      // Tool messages have role='tool' and tool_call_id instead of content
-      if (msg.role === 'tool') {
-        if (!msg.tool_call_id && !msg.name) {
-          throw new Error('Tool message must have "tool_call_id" and "name" properties');
-        }
-        if (msg.content !== undefined && typeof msg.content !== 'string') {
-          throw new Error('Tool message "content" must be a string');
-        }
-      } else {
-        // Non-tool messages must have content
-        // Assistant messages with tool_calls can have empty content
-        const hasContent = msg.content && msg.content.trim().length > 0;
-        const isAssistantWithToolCalls = msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0;
-        if (!hasContent && !isAssistantWithToolCalls) {
-          throw new Error(`Message with role "${msg.role}" must have "content" property`);
-        }
-        if (!['system', 'user', 'assistant', 'tool'].includes(msg.role)) {
-          throw new Error(`Message role must be "system", "user", "assistant", or "tool"`);
-        }
-      }
-    }
-
-    // Validate tools format if provided
-    if (tools !== undefined) {
-      if (!Array.isArray(tools)) {
-        throw new Error('Tools parameter must be an array');
-      }
-      for (const tool of tools) {
-        if (!tool.type || tool.type !== 'function') {
-          throw new Error('Each tool must have type "function"');
-        }
-        if (!tool.function || !tool.function.name) {
-          throw new Error('Each tool must have a function with a name');
-        }
-      }
-    }
-  } 
-  // Handle function-based API
-  else {
-    model = modelOrOptions;
-
-    if (!model || typeof model !== 'string') {
-      throw new Error('Model parameter is required and must be a string');
-    }
-
-    if (!prompt || typeof prompt !== 'string') {
-      throw new Error('Prompt parameter is required and must be a string');
-    }
-
-    const trimmedPrompt = prompt.trim();
-    if (!trimmedPrompt) {
-      throw new Error('Prompt parameter cannot be empty');
-    }
-
-    messages = [
-      {
-        role: 'user',
-        content: trimmedPrompt
-      }
-    ];
-
-    key = apiKey;
-  }
-
-  const trimmedModel = model.trim();
-  if (!trimmedModel) {
-    throw new Error('Model parameter cannot be empty');
-  }
-
-  const slashIndex = trimmedModel.indexOf('/');
-  if (slashIndex === -1) {
-    throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-  }
-
-  const provider = trimmedModel.substring(0, slashIndex).trim();
-  const modelName = trimmedModel.substring(slashIndex + 1).trim();
-
-  if (!provider || !modelName) {
-    throw new Error('Model must be in format "provider/model_name" (e.g., "ollama/llama2")');
-  }
-
-  const normalizedProvider = provider.toLowerCase();
-
-  switch (normalizedProvider) {
-    case 'ollama':
-      return ollamaCompletion(modelName, messages, key, tools);
-    case 'openrouter':
-      return openrouterCompletion(modelName, messages, key, tools);
-    default:
-      throw new Error(`Unsupported provider: ${provider}. Supported providers: ollama, openrouter`);
-  }
-}
+const OpenAIProvider = require('./providers/openai');
+const OllamaProvider = require('./providers/ollama');
+const OpenRouterProvider = require('./providers/openrouter');
+const { router } = require('./router');
+const { app } = require('./server');
+
+class LLMJS2 {
+  constructor(config = {}) {
+    this.providers = {
+      openai: new OpenAIProvider(config.openai || {}),
+      ollama: new OllamaProvider(config.ollama || {}),
+      openrouter: new OpenRouterProvider(config.openrouter || {})
+    };
+    this.defaultProvider = config.defaultProvider;
+    this.timeout = config.timeout || 60000;
+  }
+
+  /**
+   * Get available providers based on API keys
+   */
+  getAvailableProviders() {
+    const available = [];
+
+    const openaiKey = process.env.OPENAI_API_KEY || this.providers.openai.apiKey;
+    const ollamaKey = process.env.OLLAMA_API_KEY || this.providers.ollama.apiKey;
+    const openrouterKey = process.env.OPEN_ROUTER_API_KEY || this.providers.openrouter.apiKey;
+
+    // Check if keys are non-empty and not placeholder values
+    if (openaiKey && typeof openaiKey === 'string' && openaiKey.trim() && !openaiKey.startsWith(':')) {
+      available.push('openai');
+    }
+    if (ollamaKey && typeof ollamaKey === 'string' && ollamaKey.trim() && !ollamaKey.startsWith(':')) {
+      available.push('ollama');
+    }
+    if (openrouterKey && typeof openrouterKey === 'string' && openrouterKey.trim() && !openrouterKey.startsWith(':')) {
+      available.push('openrouter');
+    }
+
+    return available;
+  }
+
+  /**
+   * Parse model string like 'provider/model_name' or just 'model_name'
+   * Only splits on the first '/', since model names can contain '/' characters
+   */
+  parseModel(modelString) {
+    if (!modelString || typeof modelString !== 'string') {
+      return { provider: null, model: null };
+    }
+
+    const firstSlashIndex = modelString.indexOf('/');
+    if (firstSlashIndex !== -1) {
+      return {
+        provider: modelString.substring(0, firstSlashIndex),
+        model: modelString.substring(firstSlashIndex + 1)
+      };
+    }
+
+    return { provider: null, model: modelString };
+  }
+
+  /**
+   * Determine which provider to use
+   */
+  getProvider(modelString, options = {}) {
+    const { provider: specifiedProvider, model } = this.parseModel(modelString);
+
+    if (specifiedProvider) {
+      if (!this.providers[specifiedProvider]) {
+        throw new Error(`Unknown provider: ${specifiedProvider}`);
+      }
+      return { provider: this.providers[specifiedProvider], model };
+    }
+
+    // Auto-detect provider
+    const availableProviders = this.getAvailableProviders();
+
+    if (availableProviders.length === 0) {
+      throw new Error('No API keys configured. Set OPENAI_API_KEY, OLLAMA_API_KEY, or OPEN_ROUTER_API_KEY environment variables.');
+    }
+
+    // Use default provider if specified, otherwise use first available
+    const providerName = this.defaultProvider || availableProviders[0];
+    const provider = this.providers[providerName];
+
+    if (!provider) {
+      throw new Error(`Provider ${providerName} is not available`);
+    }
+
+    return { provider, model: model || provider.defaultModel };
+  }
+
+  /**
+   * Validate input parameters
+   */
+  validateInput(input) {
+    if (typeof input === 'string') {
+      // Simple string prompt
+      if (!input.trim()) {
+        throw new Error('Prompt cannot be empty');
+      }
+      return {
+        model: null,
+        messages: [{ role: 'user', content: input }],
+        options: {}
+      };
+    }
+
+    if (typeof input === 'object' && input !== null) {
+      // Object-based API
+      if (!input.messages || !Array.isArray(input.messages)) {
+        throw new Error('messages must be an array');
+      }
+
+      if (input.messages.length === 0) {
+        throw new Error('messages array cannot be empty');
+      }
+
+      // Validate message format
+      for (const msg of input.messages) {
+        if (!msg.role || !msg.content) {
+          throw new Error('Each message must have role and content properties');
+        }
+        if (!['system', 'user', 'assistant'].includes(msg.role)) {
+          throw new Error('Message role must be system, user, or assistant');
+        }
+      }
+
+      return {
+        model: input.model,
+        messages: input.messages,
+        options: {
+          temperature: input.temperature,
+          maxTokens: input.max_tokens || input.maxTokens,
+          topP: input.top_p || input.topP,
+          frequencyPenalty: input.frequency_penalty || input.frequencyPenalty,
+          presencePenalty: input.presence_penalty || input.presencePenalty,
+          stop: input.stop,
+          tools: input.tools,
+          toolChoice: input.tool_choice || input.toolChoice,
+          apiKey: input.apiKey,
+          timeout: input.timeout
+        }
+      };
+    }
+
+    throw new Error('Input must be a string or object with messages');
+  }
+
+  /**
+   * Main completion function
+   */
+  async completion(input) {
+    try {
+      const { model, messages, options } = this.validateInput(input);
+
+      const { provider, model: finalModel } = this.getProvider(model, options);
+
+      // Override provider API key if specified in options
+      if (options.apiKey) {
+        provider.apiKey = options.apiKey;
+      }
+
+      // Override timeout if specified
+      if (options.timeout) {
+        provider.timeout = options.timeout;
+      }
+
+      const result = await provider.createCompletion(messages, { ...options, model: finalModel });
+
+      return result.content;
+
+    } catch (error) {
+      // Sanitize error message to avoid leaking sensitive information
+      const message = error.message || 'Unknown error occurred';
+
+      // Don't include API keys or other sensitive data in error messages
+      const sanitizedMessage = message.replace(/Bearer\s+[^\s]+/gi, 'Bearer [REDACTED]');
+
+      throw new Error(`LLMJS2 completion failed: ${sanitizedMessage}`);
+    }
+  }
+}
+
+// Export the completion function directly for convenience
+function completion(input) {
+  const llm = new LLMJS2();
+  return llm.completion(input);
+}
+
+module.exports = {
+  completion,
+  LLMJS2,
+  router,
+  app,
+  OpenAIProvider,
+  OllamaProvider,
+  OpenRouterProvider
+};

package/package.json

@@ -1,34 +1,43 @@
-{
-  "name": "llmjs2",
-  "version": "1.1.1",
-  "description": "Abstract layer for LLM completion supporting multiple providers",
-  "main": "index.js",
-  "type": "module",
-  "exports": {
-    ".": "./index.js"
-  },
-  "files": [
-    "index.js",
-    "providers/",
-    "README.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "llm",
-    "ai",
-    "completion",
-    "llmjs2",
-    "ollama",
-    "openrouter",
-    "api"
-  ],
-  "author": "",
-  "license": "MIT",
-  "engines": {
-    "node": ">=14.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": ""
-  }
-}
+{
+  "name": "llmjs2",
+  "version": "1.3.0",
+  "description": "A unified Node.js library for connecting to multiple LLM providers: OpenAI, Ollama, and OpenRouter",
+  "main": "index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "node test.js",
+    "start": "node cli.js",
+    "server": "node cli.js",
+    "lint": "echo 'No linting configured'",
+    "typecheck": "echo 'No TypeScript configured'"
+  },
+  "keywords": [
+    "llm",
+    "openai",
+    "ollama",
+    "openrouter",
+    "ai",
+    "chatgpt",
+    "completions",
+    "unified-api"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/littlellmjs/llmjs2.git"
+  },
+  "bugs": {
+    "url": "https://github.com/littlellmjs/llmjs2/issues"
+  },
+  "homepage": "https://github.com/littlellmjs/llmjs2#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "yaml": "^2.3.4"
+  },
+  "bin": {
+    "llmjs2": "./cli.js"
+  }
+}