llmjs2 1.7.1 → 2.0.1

package/core/router.js

@@ -1,252 +0,0 @@
-const logger = require('./logger');
-const { completion } = require('./completion');
-
-function normalizeStrategy(strategy) {
-  const supportedStrategies = new Set(['default', 'random', 'sequential']);
-  return supportedStrategies.has(strategy) ? strategy : 'default';
-}
-
-function resolveApiKey(apiKey) {
-  if (typeof apiKey === 'string' && apiKey.startsWith('os.environ/')) {
-    const envVar = apiKey.replace('os.environ/', '');
-    return process.env[envVar] || apiKey;
-  }
-  return apiKey;
-}
-
-function normalizeModelList(modelList) {
-  if (!Array.isArray(modelList) || modelList.length === 0) {
-    throw new Error('Router requires a non-empty model list');
-  }
-
-  return modelList.map((model, index) => {
-    if (!model || typeof model !== 'object') {
-      throw new Error(`Model at index ${index} must be an object`);
-    }
-    if (!model.model_name) {
-      throw new Error(`Model at index ${index} is missing model_name`);
-    }
-    if (!model.llm_params || typeof model.llm_params !== 'object') {
-      throw new Error(`Model '${model.model_name}' is missing llm_params`);
-    }
-    if (!model.llm_params.model) {
-      throw new Error(`Model '${model.model_name}' is missing llm_params.model`);
-    }
-
-    return {
-      model_name: model.model_name,
-      llm_params: {
-        model: model.llm_params.model,
-        api_key: resolveApiKey(model.llm_params.api_key),
-        api_base: model.llm_params.api_base
-      }
-    };
-  });
-}
-
-function buildModelsByName(modelList) {
-  return modelList.reduce((accumulator, model) => {
-    if (!accumulator[model.model_name]) {
-      accumulator[model.model_name] = [];
-    }
-    accumulator[model.model_name].push(model);
-    return accumulator;
-  }, {});
-}
-
-function router(modelList, strategy = 'default', options = {}) {
-  const normalizedModelList = normalizeModelList(modelList);
-  const normalizedStrategy = normalizeStrategy(strategy);
-  const allowUnsafeGuardrails = Boolean(options.allowUnsafeGuardrails) || process.env.LLMJS2_ALLOW_UNSAFE_GUARDRAILS === 'true';
-  const guardrails = [];
-  const modelsByName = buildModelsByName(normalizedModelList);
-  let sequentialIndex = 0;
-
-  function getRandomItem(items) {
-    const randomIndex = Math.floor(Math.random() * items.length);
-    return items[randomIndex];
-  }
-
-  function getNextSequentialModel() {
-    const selectedModel = normalizedModelList[sequentialIndex];
-    sequentialIndex = (sequentialIndex + 1) % normalizedModelList.length;
-    return selectedModel;
-  }
-
-  function ensureModelsAvailable() {
-    if (normalizedModelList.length === 0) {
-      throw new Error('Router has no configured models');
-    }
-  }
-
-  function selectModel(modelName) {
-    ensureModelsAvailable();
-
-    if (!modelName) {
-      return autoSelectModel();
-    }
-
-    const availableModels = modelsByName[modelName];
-    if (!availableModels || availableModels.length === 0) {
-      throw new Error(`Model '${modelName}' not found in router configuration`);
-    }
-
-    if (availableModels.length === 1) {
-      return availableModels[0];
-    }
-
-    return getRandomItem(availableModels);
-  }
-
-  function autoSelectModel() {
-    ensureModelsAvailable();
-
-    switch (normalizedStrategy) {
-      case 'random':
-        return getRandomItem(normalizedModelList);
-      case 'sequential':
-      case 'default':
-      default:
-        return getNextSequentialModel();
-    }
-  }
-
-  function normalizeCompletionInput(input = {}) {
-    return {
-      modelName: input.model,
-      messages: input.messages || [],
-      stop: input.stop,
-      tools: input.tools,
-      toolChoice: input.tool_choice ?? input.toolChoice,
-      timeout: input.timeout,
-      apiKey: input.apiKey,
-      host: input.host || input.baseURL || input.baseUrl,
-      final: input.final ?? true
-    };
-  }
-
-  async function executeGuardrail(guardrail, processId, data) {
-    if (typeof guardrail.code === 'string') {
-      if (!allowUnsafeGuardrails) {
-        throw new Error(
-          `Guardrail '${guardrail.name}' uses string code, but unsafe execution is disabled. Set router option allowUnsafeGuardrails=true or LLMJS2_ALLOW_UNSAFE_GUARDRAILS=true to enable.`
-        );
-      }
-
-      const func = new Function('processId', 'data', `return (${guardrail.code})(processId, data)`);
-      return await func(processId, data);
-    }
-
-    if (typeof guardrail.code === 'function') {
-      return await guardrail.code(processId, data);
-    }
-
-    throw new Error(`Invalid guardrail code for '${guardrail.name}'`);
-  }
-
-  async function applyGuardrails(mode, processId, data) {
-    const modeLabel = mode === 'pre_call' ? 'Pre-call' : 'Post-call';
-    let currentValue = data;
-
-    for (const guardrail of guardrails) {
-      if (guardrail.mode !== mode) {
-        continue;
-      }
-
-      try {
-        const processed = await executeGuardrail(guardrail, processId, currentValue);
-        if (processed === null || processed === undefined) {
-          throw new Error(`Guardrail '${guardrail.name}' returned null/undefined`);
-        }
-        currentValue = processed;
-      } catch (error) {
-        throw new Error(`${modeLabel} guardrail '${guardrail.name}' failed: ${error.message}`);
-      }
-    }
-
-    return currentValue;
-  }
-
-  async function completionWithModel(modelConfig, input) {
-    return completion({
-      ...input,
-      model: modelConfig.llm_params.model,
-      apiKey: input.apiKey || modelConfig.llm_params.api_key,
-      host: input.host || modelConfig.llm_params.api_base,
-      final: false
-    });
-  }
-
-  function generateProcessId() {
-    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  return {
-    setGuardrails(nextGuardrails) {
-      guardrails.length = 0;
-      if (Array.isArray(nextGuardrails)) {
-        guardrails.push(...nextGuardrails);
-      }
-    },
-
-    addGuardrail(guardrail) {
-      guardrails.push(guardrail);
-    },
-
-    getAvailableModels() {
-      return Object.keys(modelsByName);
-    },
-
-    getModelStats() {
-      const stats = {};
-      Object.keys(modelsByName).forEach((modelName) => {
-        stats[modelName] = modelsByName[modelName].length;
-      });
-      return stats;
-    },
-
-    selectModel,
-
-    autoSelectModel,
-
-    executeGuardrail,
-
-    async completion(input = {}) {
-      const processId = generateProcessId();
-
-      try {
-        const normalizedInput = normalizeCompletionInput(input);
-        const selectedModel = selectModel(normalizedInput.modelName);
-
-        logger.debug('Selected model', {
-          processId,
-          model: selectedModel.llm_params.model,
-          modelName: selectedModel.model_name
-        });
-
-        const { modelName, ...completionInput } = normalizedInput;
-        const preparedInput = {
-          model: selectedModel.llm_params.model,
-          ...completionInput
-        };
-
-        const processedInput = await applyGuardrails('pre_call', processId, preparedInput);
-        const result = await completionWithModel(selectedModel, processedInput);
-        const finalResult = await applyGuardrails('post_call', processId, result);
-
-        return {
-          result: finalResult,
-          selectedModel: selectedModel.llm_params.model,
-          selectedModelName: selectedModel.model_name
-        };
-      } catch (error) {
-        logger.error('Router error', { processId, error: error.message });
-        throw error;
-      }
-    }
-  };
-}
-
-module.exports = {
-  router
-};

package/core/server.js

@@ -1,203 +0,0 @@
-const http = require('http');
-const url = require('url');
-const logger = require('./logger');
-
-class Server {
-  constructor(options = {}) {
-    this.port = options.port || process.env.PORT || 3000;
-    this.host = options.host || process.env.HOST || 'localhost';
-    this.router = options.router;
-    this.middlewares = [];
-  }
-
-  use(middleware) {
-    if (middleware && typeof middleware.completion === 'function') {
-      // It's a router
-      this.router = middleware;
-    } else if (typeof middleware === 'function') {
-      // It's middleware
-      this.middlewares.push(middleware);
-    }
-  }
-
-  async handleRequest(req, res) {
-    try {
-      // Set CORS headers
-      res.setHeader('Access-Control-Allow-Origin', '*');
-      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-
-      if (req.method === 'OPTIONS') {
-        res.writeHead(200);
-        res.end();
-        return;
-      }
-
-      const parsedUrl = url.parse(req.url, true);
-      const path = parsedUrl.pathname;
-
-      // Only handle chat completions endpoint
-      if (path !== '/v1/chat/completions' || req.method !== 'POST') {
-        this.sendError(res, 404, 'Not Found', 'Endpoint not found');
-        return;
-      }
-
-      // Parse request body
-      const body = await this.parseBody(req);
-
-      // Validate request
-      const validation = this.validateChatRequest(body);
-      if (!validation.valid) {
-        this.sendError(res, 400, 'Bad Request', validation.error);
-        return;
-      }
-
-      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);
-
-      // Send successful response
-      this.sendSuccess(res, result);
-
-    } catch (error) {
-      logger.error('Server error', { error: error.message, url: req.url, method: req.method });
-      this.sendError(res, 500, 'Internal Server Error', error.message);
-    }
-  }
-
-  parseBody(req) {
-    return new Promise((resolve, reject) => {
-      let body = '';
-      req.on('data', chunk => {
-        body += chunk.toString();
-      });
-      req.on('end', () => {
-        try {
-          resolve(JSON.parse(body));
-        } catch (error) {
-          reject(new Error('Invalid JSON in request body'));
-        }
-      });
-      req.on('error', reject);
-    });
-  }
-
-  validateChatRequest(body) {
-    if (!body) {
-      return { valid: false, error: 'Request body is required' };
-    }
-
-    if (!body.messages || !Array.isArray(body.messages)) {
-      return { valid: false, error: 'messages array is required' };
-    }
-
-    if (body.messages.length === 0) {
-      return { valid: false, error: 'messages array cannot be empty' };
-    }
-
-    for (const message of body.messages) {
-      if (!message.role || !['system', 'user', 'assistant', 'tool'].includes(message.role)) {
-        return { valid: false, error: 'Each message must have a valid role (system, user, assistant, or tool)' };
-      }
-      if (typeof message.content !== 'string') {
-        return { valid: false, error: 'Each message must have string content' };
-      }
-    }
-
-    return { valid: true };
-  }
-
-  async processCompletion(body) {
-    if (!this.router) {
-      throw new Error('No router configured. Use app.use(router) to add a router.');
-    }
-
-    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 } = routerResponse;
-
-    const assistantMessage = {
-      role: 'assistant',
-      content: typeof result === 'string' ? result : result.content || '',
-      tool_calls: typeof result === 'object' ? result.tool_calls : undefined
-    };
-
-    // Include original messages plus assistant response
-    const messages = [...(body.messages || []), assistantMessage];
-
-    return {
-      id: `chatcmpl-${Date.now()}`,
-      object: 'chat.completion',
-      created: Math.floor(Date.now() / 1000),
-      model: body.model || selectedModel, // Use selected model if auto-selected
-      choices: [
-        {
-          index: 0,
-          message: assistantMessage,
-          finish_reason: typeof result === 'object' ? (result.finishReason || 'stop') : 'stop'
-        }
-      ],
-      usage: typeof result === 'object' ? result.usage : undefined,
-      // Kept for backward compatibility with older llmjs2 clients
-      messages: messages
-    };
-  }
-
-  sendSuccess(res, data) {
-    const response = JSON.stringify(data);
-    res.writeHead(200, {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(response)
-    });
-    res.end(response);
-  }
-
-  sendError(res, statusCode, type, message) {
-    const error = {
-      error: {
-        message: message,
-        type: type.toLowerCase().replace(/\s+/g, '_')
-      }
-    };
-    const response = JSON.stringify(error);
-    res.writeHead(statusCode, {
-      'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(response)
-    });
-    res.end(response);
-  }
-
-  listen(port, host, callback) {
-    const actualPort = port || this.port;
-    const actualHost = host || this.host;
-
-    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();
-    });
-
-    return server;
-  }
-}
-
-function createApp(options = {}) {
-  return new Server(options);
-}
-
-module.exports = {
-  Server,
-  app: createApp()
-};