llmjs2 1.1.0 → 1.3.0

package/providers/ollama.js

@@ -1,88 +1,120 @@
-const OLLAMA_API_URL = 'http://localhost:11434/api/chat';
-const REQUEST_TIMEOUT = 180000; // 60 seconds
-
-/**
- * Ollama completion provider
- * @param {string} model - Model name (e.g., "llama2")
- * @param {array} messages - Array of message objects with role and content
- * @param {string} [apiKey] - Optional API key
- * @param {array} [tools] - Optional array of tool definitions
- * @returns {Promise<string|object>} The completion result (string or object with tool calls)
- */
-export async function ollamaCompletion(model, messages, apiKey, tools) {
-  const key = apiKey || process.env.OLLAMA_API_KEY;
-
-  if (!key) {
-    throw new Error('Ollama API key is required. Provide it as parameter or set OLLAMA_API_KEY environment variable.');
-  }
-
-  const requestBody = {
-    model: model,
-    messages: messages,
-    stream: false
-  };
-
-  
-
-  if (tools && tools.length > 0) {
-    requestBody.tools = tools;
-  }
-
-
-
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
-
-
-
-
-  try {
-    const response = await fetch(OLLAMA_API_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${key}`
-      },
-      body: JSON.stringify(requestBody),
-      signal: controller.signal
-    });
-
-
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Ollama API error (${response.status}): ${errorText}`);
-    }
-
-    const data = await response.json();
-
-    if (!data.message) {
-      throw new Error('Invalid response format from Ollama API');
-    }
-
-    // Return tool calls if present, otherwise return content
-    if (data.message.tool_calls && data.message.tool_calls.length > 0) {
-      return {
-        content: data.message.content || '',
-        tool_calls: data.message.tool_calls
-      };
-    }
-
-    return data.message.content || '';
-  } catch (error) {
-    clearTimeout(timeoutId);
-
-    if (error.name === 'AbortError') {
-      throw new Error('Ollama request timed out after 60 seconds');
-    }
-
-    if (error.message.includes('Ollama API error')) {
-      throw error;
-    }
-
-    throw new Error(`Ollama request failed: ${error.message}`);
-  }
-}
+const https = require('https');
+
+class OllamaProvider {
+  constructor(config = {}) {
+    this.baseURL = config.baseURL || process.env.OLLAMA_BASE_URL || 'https://ollama.com/api/chat';
+    this.apiKey = config.apiKey || process.env.OLLAMA_API_KEY;
+    this.defaultModel = config.defaultModel || process.env.OLLAMA_DEFAULT_MODEL || 'minimax-m2.5:cloud';
+    this.timeout = config.timeout || 120000; // 2 minutes (LLMs can be slow)
+  }
+
+  async makeRequest(data) {
+    if (!this.apiKey) {
+      throw new Error('Ollama API key is required. Set OLLAMA_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)
+      }
+    };
+
+    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(`Ollama API error (${res.statusCode}): ${error.error?.message || error.message || body }`));
+            }
+          } catch (parseError) {
+            reject(new Error(`Failed to parse Ollama response: ${parseError.message}`));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`Ollama request failed: ${error.message}`));
+      });
+
+      req.setTimeout(this.timeout, () => {
+        req.destroy();
+        reject(new Error('Ollama request timed out'));
+      });
+
+      req.write(postData);
+      req.end();
+    });
+  }
+
+  async createCompletion(messages, options = {}) {
+    const data = {
+      model: options.model || this.defaultModel,
+      messages: messages,
+      stream: false, // We handle non-streaming for simplicity
+      format: options.format,
+      options: {
+        temperature: options.temperature || 0.7,
+        top_p: options.topP,
+        num_predict: options.maxTokens,
+        repeat_penalty: options.frequencyPenalty,
+        presence_penalty: options.presencePenalty,
+        stop: options.stop,
+        num_ctx: options.numCtx || 4096
+      },
+      tools: options.tools,
+      keep_alive: options.keepAlive || '5m'
+    };
+
+    // Remove undefined values
+    Object.keys(data).forEach(key => {
+      if (data[key] === undefined) {
+        delete data[key];
+      }
+    });
+
+    if (data.options) {
+      Object.keys(data.options).forEach(key => {
+        if (data.options[key] === undefined) {
+          delete data.options[key];
+        }
+      });
+    }
+
+    const response = await this.makeRequest(data);
+
+    return {
+      content: response.message?.content || '',
+      role: response.message?.role || 'assistant',
+      toolCalls: response.message?.tool_calls,
+      usage: {
+        prompt_eval_count: response.prompt_eval_count,
+        eval_count: response.eval_count,
+        total_duration: response.total_duration
+      },
+      model: response.model,
+      finishReason: response.done_reason || (response.done ? 'stop' : null)
+    };
+  }
+}
+
+module.exports = OllamaProvider;

package/providers/openai.js

@@ -0,0 +1,104 @@
+const https = require('https');
+
+class OpenAIProvider {
+  constructor(config = {}) {
+    this.baseURL = config.baseURL || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
+    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+    this.defaultModel = config.defaultModel || process.env.OPENAI_DEFAULT_MODEL || 'gpt-3.5-turbo';
+    this.timeout = config.timeout || 60000; // 60 seconds
+  }
+
+  async makeRequest(endpoint, data) {
+    if (!this.apiKey) {
+      throw new Error('OpenAI API key is required. Set OPENAI_API_KEY environment variable or pass apiKey in config.');
+    }
+
+    const requestUrl = `${this.baseURL}${endpoint}`;
+    const postData = JSON.stringify(data);
+
+    const parsedUrl = new URL(requestUrl);
+
+    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)
+      }
+    };
+
+    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(`OpenAI API error (${res.statusCode}): ${error.error?.message || 'Unknown error'}`));
+            }
+          } catch (parseError) {
+            reject(new Error(`Failed to parse OpenAI response: ${parseError.message}`));
+          }
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(new Error(`OpenAI request failed: ${error.message}`));
+      });
+
+      req.setTimeout(this.timeout, () => {
+        req.destroy();
+        reject(new Error('OpenAI 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
+    };
+
+    // Remove undefined values
+    Object.keys(data).forEach(key => {
+      if (data[key] === undefined) {
+        delete data[key];
+      }
+    });
+
+    const response = await this.makeRequest('/chat/completions', data);
+
+    return {
+      content: response.choices[0]?.message?.content || '',
+      role: response.choices[0]?.message?.role || 'assistant',
+      toolCalls: response.choices[0]?.message?.tool_calls,
+      usage: response.usage,
+      model: response.model,
+      finishReason: response.choices[0]?.finish_reason
+    };
+  }
+}
+
+module.exports = OpenAIProvider;

package/providers/openrouter.js

@@ -1,79 +1,113 @@
-const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions';
-const REQUEST_TIMEOUT = 180000; // 60 seconds
-
-/**
- * OpenRouter completion provider
- * @param {string} model - Model name (e.g., "meta-llama/llama-2-70b-chat")
- * @param {array} messages - Array of message objects with role and content
- * @param {string} [apiKey] - Optional API key
- * @param {array} [tools] - Optional array of tool definitions
- * @returns {Promise<string|object>} The completion result (string or object with tool calls)
- */
-export async function openrouterCompletion(model, messages, apiKey, tools) {
-  const key = apiKey || process.env.OPEN_ROUTER_API_KEY;
-
-  if (!key) {
-    throw new Error('OpenRouter API key is required. Provide it as parameter or set OPEN_ROUTER_API_KEY environment variable.');
-  }
-
-  const requestBody = {
-    model: model,
-    messages: messages
-  };
-
-  if (tools && tools.length > 0) {
-    requestBody.tools = tools;
-  }
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
-
-  try {
-    const response = await fetch(OPENROUTER_API_URL, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${key}`
-      },
-      body: JSON.stringify(requestBody),
-      signal: controller.signal
-    });
-
-    clearTimeout(timeoutId);
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
-    }
-
-    const data = await response.json();
-
-    if (!data.choices || !data.choices[0] || !data.choices[0].message) {
-      throw new Error('Invalid response format from OpenRouter API');
-    }
-
-    const message = data.choices[0].message;
-
-    // Return tool calls if present, otherwise return content
-    if (message.tool_calls && message.tool_calls.length > 0) {
-      return {
-        content: message.content || '',
-        tool_calls: message.tool_calls
-      };
-    }
-
-    return message.content || '';
-  } catch (error) {
-    clearTimeout(timeoutId);
-
-    if (error.name === 'AbortError') {
-      throw new Error('OpenRouter request timed out after 60 seconds');
-    }
-
-    if (error.message.includes('OpenRouter API error')) {
-      throw error;
-    }
-
-    throw new Error(`OpenRouter request failed: ${error.message}`);
-  }
-}
+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',
+      toolCalls: response.choices[0]?.message?.tool_calls,
+      usage: response.usage,
+      model: response.model,
+      finishReason: response.choices[0]?.finish_reason
+    };
+  }
+}
+
+module.exports = OpenRouterProvider;