llmjs2 1.0.1 → 1.0.6

package/src/index.ts

@@ -1,268 +0,0 @@
-/**
- * llmjs2 - Enterprise-grade LLM abstraction layer
- * Unified API for OpenAI and Ollama
- */
-
-import {
-  CompletionRequest,
-  CompletionResponse,
-  CompletionChunk,
-  CompletionOptions,
-  ProviderType,
-  IProvider,
-} from './types.js';
-import { OpenAIProvider } from './providers/openai.js';
-import { OllamaProvider } from './providers/ollama.js';
-import { LLMError } from './providers/base.js';
-
-/**
- * Global configuration for completion
- */
-let globalOptions: CompletionOptions = {};
-
-/**
- * Provider cache
- */
-const providerCache: Map<string, IProvider> = new Map();
-
-/**
- * Configure global settings
- */
-export function configure(options: CompletionOptions): void {
-  globalOptions = { ...globalOptions, ...options };
-}
-
-/**
- * Get provider type from model string
- */
-function getProviderType(model: string): ProviderType {
-  if (model.startsWith('openai/')) {
-    return 'openai';
-  }
-  if (model.startsWith('ollama/')) {
-    return 'ollama';
-  }
-  // Default to openai if no prefix specified
-  return 'openai';
-}
-
-/**
- * Create appropriate provider instance
- */
-function createProvider(
-  providerType: ProviderType,
-  request: CompletionRequest
-): IProvider {
-  const cacheKey = `${providerType}:${request.apiKey || 'default'}:${request.baseUrl || 'default'}`;
-
-  // Return cached provider if available
-  if (providerCache.has(cacheKey)) {
-    return providerCache.get(cacheKey)!;
-  }
-
-  let provider: IProvider;
-
-  switch (providerType) {
-    case 'openai': {
-      const apiKey = request.apiKey || process.env.OPENAI_API_KEY;
-      if (!apiKey) {
-        throw new LLMError(
-          'OpenAI API key is required. Pass it as apiKey in the request or set OPENAI_API_KEY environment variable.',
-          'MISSING_API_KEY'
-        );
-      }
-      provider = new OpenAIProvider({
-        type: 'openai',
-        apiKey: apiKey,
-        baseUrl: request.baseUrl,
-        timeout: request.timeout ?? globalOptions.globalTimeout,
-        retry: request.retry ?? globalOptions.globalRetry,
-      });
-      break;
-    }
-
-    case 'ollama': {
-      provider = new OllamaProvider({
-        type: 'ollama',
-        baseUrl: request.baseUrl,
-        timeout: request.timeout ?? globalOptions.globalTimeout,
-        retry: request.retry ?? globalOptions.globalRetry,
-      });
-      break;
-    }
-
-    default:
-      throw new LLMError(`Unsupported provider: ${providerType}`, 'UNKNOWN_PROVIDER');
-  }
-
-  // Apply global settings
-  if (globalOptions.debug) {
-    provider.setDebug(true);
-  }
-
-  if (globalOptions.logger) {
-    provider.setLogger(globalOptions.logger);
-  }
-
-  // Cache the provider
-  providerCache.set(cacheKey, provider);
-
-  return provider;
-}
-
-/**
- * Create a completion request
- *
- * @example
- * import { completion } from 'llmjs2';
- *
- * const result = await completion({
- *   model: 'openai/gpt-4',
- *   apiKey: 'sk-...',
- *   messages: [
- *     { role: 'user', content: 'Hello!' }
- *   ]
- * });
- *
- * console.log(result.content);
- */
-export async function completion(
-  request: CompletionRequest
-): Promise<CompletionResponse> {
-  if (!request.model) {
-    throw new LLMError('Model is required', 'MISSING_MODEL');
-  }
-
-  const providerType = getProviderType(request.model);
-  const provider = createProvider(providerType, request);
-
-  try {
-    return await provider.complete(request);
-  } catch (error) {
-    if (error instanceof LLMError) {
-      throw error;
-    }
-    throw new LLMError(
-      `Completion failed: ${error instanceof Error ? error.message : String(error)}`,
-      'COMPLETION_FAILED',
-      undefined,
-      error
-    );
-  }
-}
-
-/**
- * Stream a completion request
- *
- * @example
- * import { streamCompletion } from 'llmjs2';
- *
- * const stream = streamCompletion({
- *   model: 'openai/gpt-4',
- *   apiKey: 'sk-...',
- *   messages: [
- *     { role: 'user', content: 'Write a poem' }
- *   ]
- * });
- *
- * for await (const chunk of stream) {
- *   process.stdout.write(chunk.delta);
- * }
- */
-export async function* streamCompletion(
-  request: CompletionRequest
-): AsyncIterable<CompletionChunk> {
-  if (!request.model) {
-    throw new LLMError('Model is required', 'MISSING_MODEL');
-  }
-
-  const providerType = getProviderType(request.model);
-  const provider = createProvider(providerType, request);
-
-  try {
-    yield* provider.completeStream(request);
-  } catch (error) {
-    if (error instanceof LLMError) {
-      throw error;
-    }
-    throw new LLMError(
-      `Stream failed: ${error instanceof Error ? error.message : String(error)}`,
-      'STREAM_FAILED',
-      undefined,
-      error
-    );
-  }
-}
-
-/**
- * Validate provider connectivity and configuration
- */
-export async function validateProvider(
-  model: string,
-  apiKey?: string,
-  baseUrl?: string
-): Promise<void> {
-  const providerType = getProviderType(model);
-
-  const request: CompletionRequest = {
-    model,
-    apiKey,
-    baseUrl,
-    messages: [{ role: 'user', content: 'test' }],
-  };
-
-  const provider = createProvider(providerType, request);
-
-  try {
-    await provider.validate();
-  } catch (error) {
-    if (error instanceof LLMError) {
-      throw error;
-    }
-    throw new LLMError(
-      `Validation failed: ${error instanceof Error ? error.message : String(error)}`,
-      'VALIDATION_FAILED'
-    );
-  }
-}
-
-/**
- * Clear provider cache
- */
-export function clearProviderCache(): void {
-  providerCache.clear();
-}
-
-/**
- * Export types for consumers
- */
-export type {
-  CompletionRequest,
-  CompletionResponse,
-  CompletionChunk,
-  CompletionOptions,
-  Message,
-  MessageRole,
-  Tool,
-  ProviderType,
-  ProviderConfig,
-  ProviderError,
-} from './types.js';
-
-/**
- * Export error class
- */
-export { LLMError };
-
-/**
- * Export provider classes for advanced use cases
- */
-export { OpenAIProvider } from './providers/openai.js';
-export { OllamaProvider } from './providers/ollama.js';
-export { BaseProvider } from './providers/base.js';
-
-/**
- * Export Agent for stateful conversations
- */
-export { Agent } from './agent.js';
-export type { AgentConfig, AgentGenerateRequest, AgentGenerateResponse } from './agent.js';

package/src/providers/base.ts

@@ -1,216 +0,0 @@
-/**
- * Base provider class with common functionality
- */
-
-import {
-  IProvider,
-  CompletionRequest,
-  CompletionResponse,
-  CompletionChunk,
-  ProviderConfig,
-  ProviderError,
-} from '../types.js';
-
-/**
- * Validation helper for requests
- */
-export function validateCompletionRequest(request: CompletionRequest): void {
-  if (!request.model) {
-    throw new Error('Model is required');
-  }
-
-  if (!Array.isArray(request.messages) || request.messages.length === 0) {
-    throw new Error('Messages array is required and must not be empty');
-  }
-
-  // Validate message structure
-  for (const msg of request.messages) {
-    if (!msg.role || msg.content === undefined || msg.content === null) {
-      throw new Error('Each message must have role and content');
-    }
-    if (!['system', 'user', 'assistant'].includes(msg.role)) {
-      throw new Error(`Invalid role: ${msg.role}`);
-    }
-    if (typeof msg.content !== 'string') {
-      throw new Error('Message content must be a string');
-    }
-  }
-
-  // Validate numeric ranges
-  if (request.temperature !== undefined && request.temperature !== null) {
-    if (typeof request.temperature !== 'number' || request.temperature < 0 || request.temperature > 2) {
-      throw new Error('Temperature must be a number between 0 and 2');
-    }
-  }
-
-  if (request.topP !== undefined && request.topP !== null) {
-    if (typeof request.topP !== 'number' || request.topP < 0 || request.topP > 1) {
-      throw new Error('topP must be a number between 0 and 1');
-    }
-  }
-
-  if (request.maxTokens !== undefined && request.maxTokens !== null) {
-    if (typeof request.maxTokens !== 'number' || request.maxTokens < 1) {
-      throw new Error('maxTokens must be a number greater than 0');
-    }
-  }
-
-  if (request.frequencyPenalty !== undefined && request.frequencyPenalty !== null) {
-    if (typeof request.frequencyPenalty !== 'number' || request.frequencyPenalty < -2 || request.frequencyPenalty > 2) {
-      throw new Error('frequencyPenalty must be a number between -2 and 2');
-    }
-  }
-
-  if (request.presencePenalty !== undefined && request.presencePenalty !== null) {
-    if (typeof request.presencePenalty !== 'number' || request.presencePenalty < -2 || request.presencePenalty > 2) {
-      throw new Error('presencePenalty must be a number between -2 and 2');
-    }
-  }
-}
-
-/**
- * Custom error class for provider errors
- */
-export class LLMError extends Error implements ProviderError {
-  code?: string;
-  statusCode?: number;
-  details?: unknown;
-  retryable?: boolean;
-
-  constructor(
-    message: string,
-    code?: string,
-    statusCode?: number,
-    details?: unknown,
-    retryable?: boolean
-  ) {
-    super(message);
-    this.name = 'LLMError';
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.retryable = retryable ?? false;
-  }
-}
-
-/**
- * Retry helper with exponential backoff
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options: {
-    maxRetries?: number;
-    backoffMultiplier?: number;
-    initialDelayMs?: number;
-  } = {}
-): Promise<T> {
-  const maxRetries = options.maxRetries ?? 3;
-  const backoffMultiplier = options.backoffMultiplier ?? 2;
-  const initialDelayMs = options.initialDelayMs ?? 1000;
-
-  let lastError: Error | undefined;
-
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error as Error;
-
-      // Check if error is retryable
-      const isRetryable =
-        error instanceof LLMError
-          ? error.retryable
-          : error instanceof Error &&
-            (error.message.includes('timeout') ||
-              error.message.includes('ECONNREFUSED') ||
-              error.message.includes('ENOTFOUND'));
-
-      if (!isRetryable || attempt === maxRetries - 1) {
-        throw error;
-      }
-
-      // Exponential backoff
-      const delay = initialDelayMs * Math.pow(backoffMultiplier, attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  }
-
-  throw lastError || new Error('Retry failed');
-}
-
-/**
- * Base provider class
- */
-export abstract class BaseProvider implements IProvider {
-  protected config: ProviderConfig;
-  protected debug: boolean;
-  protected logger: (level: string, message: string, data?: unknown) => void;
-
-  constructor(config: ProviderConfig) {
-    this.config = config;
-    this.debug = false;
-    this.logger = (level: string, message: string, data?: unknown) => {
-      if (this.debug) {
-        console.log(`[${level}] ${message}`, data ?? '');
-      }
-    };
-  }
-
-  setDebug(debug: boolean): void {
-    this.debug = debug;
-  }
-
-  setLogger(
-    logger: (level: string, message: string, data?: unknown) => void
-  ): void {
-    this.logger = logger;
-  }
-
-  abstract complete(request: CompletionRequest): Promise<CompletionResponse>;
-
-  abstract completeStream(
-    request: CompletionRequest
-  ): AsyncIterable<CompletionChunk>;
-
-  abstract validate(): Promise<void>;
-
-  abstract parseModel(model: string): string;
-
-  /**
-   * Get the timeout for a request
-   */
-  protected getTimeout(request?: CompletionRequest): number {
-    return (
-      request?.timeout ??
-      this.config.timeout ??
-      30000 // Default 30 seconds
-    );
-  }
-
-  /**
-   * Get retry config
-   */
-  protected getRetryConfig(request?: CompletionRequest) {
-    return {
-      maxRetries: request?.retry?.maxRetries ?? this.config.retry?.maxRetries ?? 3,
-      backoffMultiplier:
-        request?.retry?.backoffMultiplier ??
-        this.config.retry?.backoffMultiplier ??
-        2,
-      initialDelayMs:
-        request?.retry?.initialDelayMs ??
-        this.config.retry?.initialDelayMs ??
-        1000,
-    };
-  }
-
-  /**
-   * Get headers including custom headers
-   */
-  protected getHeaders(request?: CompletionRequest): Record<string, string> {
-    return {
-      ...(this.config.headers ?? {}),
-      ...(request?.headers ?? {}),
-    };
-  }
-}

package/src/providers/index.ts

@@ -1,8 +0,0 @@
-/**
- * Provider exports
- */
-
-export { OpenAIProvider } from './openai.js';
-export { OllamaProvider } from './ollama.js';
-export { BaseProvider } from './base.js';
-export type { IProvider } from '../types.js';