@libredb/studio 0.9.7

package/src/lib/llm/providers/custom.ts

@@ -0,0 +1,181 @@
+/**
+ * Custom LLM Provider
+ * Generic OpenAI-compatible endpoint for LiteLLM, LMStudio, vLLM, etc.
+ */
+
+import { BaseLLMProvider } from '../base-provider';
+import {
+  type LLMConfig,
+  type LLMStreamOptions,
+  LLMAuthError,
+  LLMRateLimitError,
+  LLMStreamError,
+  LLMConfigError,
+} from '../types';
+import { createStreamFromSSEResponse } from '../utils/streaming';
+import { logger } from '@/lib/logger';
+
+// ============================================================================
+// Custom Provider
+// ============================================================================
+
+export class CustomProvider extends BaseLLMProvider {
+  private baseUrl: string;
+
+  constructor(config: LLMConfig) {
+    super(config);
+    this.validate();
+    this.baseUrl = this.ensureApiUrl();
+  }
+
+  /**
+   * Validate configuration - requires API URL
+   */
+  public validate(): void {
+    if (!this.config.apiUrl || this.config.apiUrl.trim() === '') {
+      throw new LLMConfigError(
+        'Custom provider requires LLM_API_URL environment variable.',
+        'custom'
+      );
+    }
+
+    if (!this.config.model || this.config.model.trim() === '') {
+      throw new LLMConfigError(
+        'Model name is required for Custom provider.',
+        'custom'
+      );
+    }
+  }
+
+  /**
+   * Stream completion from custom endpoint
+   */
+  public async stream(options: LLMStreamOptions): Promise<ReadableStream<Uint8Array>> {
+    return this.streamWithRetry(async () => {
+      const model = this.getModel(options);
+      const messages = this.buildMessages(options);
+
+      try {
+        const response = await this.fetchStream(model, messages, options);
+        await this.validateResponse(response);
+
+        return createStreamFromSSEResponse(response, 'custom');
+      } catch (error) {
+        if (
+          error instanceof LLMAuthError ||
+          error instanceof LLMRateLimitError ||
+          error instanceof LLMConfigError
+        ) {
+          throw error;
+        }
+        throw this.mapError(error);
+      }
+    });
+  }
+
+  /**
+   * Build messages array in OpenAI format
+   */
+  private buildMessages(options: LLMStreamOptions): Array<{ role: string; content: string }> {
+    return options.messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+
+  /**
+   * Fetch streaming response from custom endpoint
+   */
+  private async fetchStream(
+    model: string,
+    messages: Array<{ role: string; content: string }>,
+    options: LLMStreamOptions
+  ): Promise<Response> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    // Add API key if provided
+    if (this.config.apiKey) {
+      headers.Authorization = `Bearer ${this.config.apiKey}`;
+    }
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        model,
+        messages,
+        stream: true,
+        ...(options.temperature !== undefined && { temperature: options.temperature }),
+        ...(options.maxTokens !== undefined && { max_tokens: options.maxTokens }),
+      }),
+    });
+
+    return response;
+  }
+
+  /**
+   * Validate response status
+   */
+  private async validateResponse(response: Response): Promise<void> {
+    if (response.ok) {
+      return;
+    }
+
+    let errorMessage = `HTTP ${response.status}`;
+
+    try {
+      const errorBody = await response.text();
+      const errorJson = JSON.parse(errorBody);
+      errorMessage = errorJson.error?.message ?? errorBody;
+    } catch {
+      logger.debug('Could not parse error response body as JSON', { provider: 'custom' });
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      throw new LLMAuthError(
+        'Authentication failed. Check your API key configuration.',
+        'custom'
+      );
+    }
+
+    if (response.status === 429) {
+      throw new LLMRateLimitError(
+        'Rate limit exceeded. Please try again later.',
+        'custom'
+      );
+    }
+
+    throw new LLMStreamError(`Custom API error: ${errorMessage}`, 'custom');
+  }
+
+  /**
+   * Map errors to LLM error types
+   */
+  private mapError(error: unknown): Error {
+    if (error instanceof LLMStreamError) {
+      return error;
+    }
+
+    if (!(error instanceof Error)) {
+      return new LLMStreamError(String(error), 'custom');
+    }
+
+    const message = error.message.toLowerCase();
+
+    // Connection errors
+    if (
+      message.includes('econnrefused') ||
+      message.includes('fetch failed') ||
+      message.includes('network')
+    ) {
+      return new LLMStreamError(
+        `Cannot connect to custom endpoint at ${this.baseUrl}. Make sure the service is running.`,
+        'custom'
+      );
+    }
+
+    return new LLMStreamError(error.message, 'custom');
+  }
+}

package/src/lib/llm/providers/gemini.ts

@@ -0,0 +1,126 @@
+/**
+ * Gemini LLM Provider
+ * Google Gemini AI integration using @google/generative-ai SDK
+ */
+
+import { GoogleGenerativeAI, type GenerateContentStreamResult } from '@google/generative-ai';
+import { BaseLLMProvider } from '../base-provider';
+import {
+  type LLMConfig,
+  type LLMStreamOptions,
+  LLMAuthError,
+  LLMRateLimitError,
+  LLMSafetyError,
+  LLMStreamError,
+} from '../types';
+import { encodeText, streamFromAsyncIterable } from '../utils/streaming';
+
+// ============================================================================
+// Gemini Provider
+// ============================================================================
+
+export class GeminiProvider extends BaseLLMProvider {
+  private client: GoogleGenerativeAI;
+
+  constructor(config: LLMConfig) {
+    super(config);
+    this.validate();
+    this.client = new GoogleGenerativeAI(this.ensureApiKey());
+  }
+
+  /**
+   * Stream completion from Gemini
+   */
+  public async stream(options: LLMStreamOptions): Promise<ReadableStream<Uint8Array>> {
+    return this.streamWithRetry(async () => {
+      const model = this.getModel(options);
+      const systemInstruction = this.getSystemMessage(options);
+      const messages = this.getNonSystemMessages(options);
+
+      // Build the prompt from messages
+      const prompt = messages.map((m) => m.content).join('\n\n');
+
+      try {
+        const generativeModel = this.client.getGenerativeModel({
+          model,
+          systemInstruction,
+        });
+
+        const result = await generativeModel.generateContentStream(prompt);
+
+        return this.createStreamFromResult(result);
+      } catch (error) {
+        throw this.mapError(error);
+      }
+    });
+  }
+
+  /**
+   * Create ReadableStream from Gemini stream result
+   */
+  private createStreamFromResult(
+    result: GenerateContentStreamResult
+  ): ReadableStream<Uint8Array> {
+    return streamFromAsyncIterable(result.stream, (chunk) => {
+      try {
+        const text = chunk.text();
+        return text ? encodeText(text) : null;
+      } catch {
+        // Handle safety-blocked chunks
+        return null;
+      }
+    });
+  }
+
+  /**
+   * Map Gemini errors to LLM error types
+   */
+  private mapError(error: unknown): Error {
+    if (!(error instanceof Error)) {
+      return new LLMStreamError(String(error), 'gemini');
+    }
+
+    const message = error.message.toLowerCase();
+
+    // Authentication errors
+    if (
+      message.includes('api key') ||
+      message.includes('invalid key') ||
+      message.includes('unauthorized') ||
+      message.includes('permission denied')
+    ) {
+      return new LLMAuthError(
+        'Invalid API Key. Please check your Gemini API configuration.',
+        'gemini'
+      );
+    }
+
+    // Rate limit errors
+    if (
+      message.includes('quota') ||
+      message.includes('rate limit') ||
+      message.includes('resource exhausted') ||
+      message.includes('429')
+    ) {
+      return new LLMRateLimitError(
+        'AI usage limit reached. Please try again later or upgrade your plan.',
+        'gemini'
+      );
+    }
+
+    // Safety filter errors
+    if (
+      message.includes('safety') ||
+      message.includes('blocked') ||
+      message.includes('harm')
+    ) {
+      return new LLMSafetyError(
+        'The prompt was blocked by safety filters. Please modify your request.',
+        'gemini'
+      );
+    }
+
+    // Generic stream error
+    return new LLMStreamError(error.message, 'gemini');
+  }
+}

package/src/lib/llm/providers/ollama.ts

@@ -0,0 +1,154 @@
+/**
+ * Ollama LLM Provider
+ * Local LLM integration via OpenAI-compatible API
+ */
+
+import { BaseLLMProvider } from '../base-provider';
+import {
+  type LLMConfig,
+  type LLMStreamOptions,
+  LLMStreamError,
+  LLMConfigError,
+} from '../types';
+import { createStreamFromSSEResponse } from '../utils/streaming';
+import { DEFAULT_API_URLS } from '../utils/config';
+import { logger } from '@/lib/logger';
+
+// ============================================================================
+// Ollama Provider
+// ============================================================================
+
+export class OllamaProvider extends BaseLLMProvider {
+  private baseUrl: string;
+
+  constructor(config: LLMConfig) {
+    super(config);
+    this.baseUrl = config.apiUrl ?? DEFAULT_API_URLS.ollama;
+  }
+
+  /**
+   * Override validation - Ollama doesn't require API key
+   */
+  public validate(): void {
+    if (!this.config.model || this.config.model.trim() === '') {
+      throw new LLMConfigError(
+        'Model name is required for Ollama provider.',
+        'ollama'
+      );
+    }
+  }
+
+  /**
+   * Stream completion from Ollama
+   */
+  public async stream(options: LLMStreamOptions): Promise<ReadableStream<Uint8Array>> {
+    return this.streamWithRetry(async () => {
+      const model = this.getModel(options);
+      const messages = this.buildMessages(options);
+
+      try {
+        const response = await this.fetchStream(model, messages, options);
+        await this.validateResponse(response);
+
+        return createStreamFromSSEResponse(response, 'ollama');
+      } catch (error) {
+        throw this.mapError(error);
+      }
+    });
+  }
+
+  /**
+   * Build messages array in OpenAI format
+   */
+  private buildMessages(options: LLMStreamOptions): Array<{ role: string; content: string }> {
+    return options.messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+
+  /**
+   * Fetch streaming response from Ollama API
+   */
+  private async fetchStream(
+    model: string,
+    messages: Array<{ role: string; content: string }>,
+    options: LLMStreamOptions
+  ): Promise<Response> {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        // Ollama accepts 'ollama' or empty string as API key
+        Authorization: 'Bearer ollama',
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        stream: true,
+        ...(options.temperature !== undefined && { temperature: options.temperature }),
+        ...(options.maxTokens !== undefined && { max_tokens: options.maxTokens }),
+      }),
+    });
+
+    return response;
+  }
+
+  /**
+   * Validate response status
+   */
+  private async validateResponse(response: Response): Promise<void> {
+    if (response.ok) {
+      return;
+    }
+
+    let errorMessage = `HTTP ${response.status}`;
+
+    try {
+      const errorBody = await response.text();
+      const errorJson = JSON.parse(errorBody);
+      errorMessage = errorJson.error?.message ?? errorBody;
+    } catch {
+      logger.debug('Could not parse error response body as JSON', { provider: 'ollama' });
+    }
+
+    // Ollama-specific errors
+    if (response.status === 404) {
+      throw new LLMConfigError(
+        `Model not found. Make sure "${this.config.model}" is pulled in Ollama.`,
+        'ollama'
+      );
+    }
+
+    throw new LLMStreamError(`Ollama API error: ${errorMessage}`, 'ollama');
+  }
+
+  /**
+   * Map errors to LLM error types
+   */
+  private mapError(error: unknown): Error {
+    if (error instanceof LLMConfigError || error instanceof LLMStreamError) {
+      return error;
+    }
+
+    if (!(error instanceof Error)) {
+      return new LLMStreamError(String(error), 'ollama');
+    }
+
+    const message = error.message.toLowerCase();
+
+    // Connection errors - Ollama not running
+    if (
+      message.includes('econnrefused') ||
+      message.includes('fetch failed') ||
+      message.includes('network')
+    ) {
+      return new LLMStreamError(
+        `Cannot connect to Ollama at ${this.baseUrl}. Make sure Ollama is running.`,
+        'ollama'
+      );
+    }
+
+    return new LLMStreamError(error.message, 'ollama');
+  }
+}

package/src/lib/llm/providers/openai.ts

@@ -0,0 +1,146 @@
+/**
+ * OpenAI LLM Provider
+ * OpenAI Chat Completions API with SSE streaming
+ */
+
+import { BaseLLMProvider } from '../base-provider';
+import {
+  type LLMConfig,
+  type LLMStreamOptions,
+  LLMAuthError,
+  LLMRateLimitError,
+  LLMStreamError,
+} from '../types';
+import { createStreamFromSSEResponse } from '../utils/streaming';
+import { DEFAULT_API_URLS } from '../utils/config';
+import { logger } from '@/lib/logger';
+
+// ============================================================================
+// OpenAI Provider
+// ============================================================================
+
+export class OpenAIProvider extends BaseLLMProvider {
+  protected baseUrl: string;
+
+  constructor(config: LLMConfig) {
+    super(config);
+    this.validate();
+    this.baseUrl = config.apiUrl ?? DEFAULT_API_URLS.openai;
+  }
+
+  /**
+   * Stream completion from OpenAI
+   */
+  public async stream(options: LLMStreamOptions): Promise<ReadableStream<Uint8Array>> {
+    return this.streamWithRetry(async () => {
+      const model = this.getModel(options);
+      const messages = this.buildMessages(options);
+
+      try {
+        const response = await this.fetchStream(model, messages, options);
+        await this.validateResponse(response);
+
+        return createStreamFromSSEResponse(response, this.name);
+      } catch (error) {
+        if (error instanceof LLMAuthError || error instanceof LLMRateLimitError) {
+          throw error;
+        }
+        throw this.mapError(error);
+      }
+    });
+  }
+
+  /**
+   * Build messages array in OpenAI format
+   */
+  protected buildMessages(options: LLMStreamOptions): Array<{ role: string; content: string }> {
+    return options.messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+  }
+
+  /**
+   * Fetch streaming response from OpenAI API
+   */
+  protected async fetchStream(
+    model: string,
+    messages: Array<{ role: string; content: string }>,
+    options: LLMStreamOptions
+  ): Promise<Response> {
+    const apiKey = this.ensureApiKey();
+
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        stream: true,
+        ...(options.temperature !== undefined && { temperature: options.temperature }),
+        ...(options.maxTokens !== undefined && { max_tokens: options.maxTokens }),
+      }),
+    });
+
+    return response;
+  }
+
+  /**
+   * Validate response status and throw appropriate errors
+   */
+  protected async validateResponse(response: Response): Promise<void> {
+    if (response.ok) {
+      return;
+    }
+
+    let errorMessage = `HTTP ${response.status}`;
+
+    try {
+      const errorBody = await response.text();
+      const errorJson = JSON.parse(errorBody);
+      errorMessage = errorJson.error?.message ?? errorBody;
+    } catch {
+      logger.debug('Could not parse error response body as JSON', { provider: 'openai' });
+    }
+
+    if (response.status === 401 || response.status === 403) {
+      throw new LLMAuthError(
+        'Invalid API Key. Please check your OpenAI API configuration.',
+        'openai'
+      );
+    }
+
+    if (response.status === 429) {
+      throw new LLMRateLimitError(
+        'Rate limit exceeded. Please try again later or upgrade your plan.',
+        'openai'
+      );
+    }
+
+    throw new LLMStreamError(`OpenAI API error: ${errorMessage}`, 'openai');
+  }
+
+  /**
+   * Map errors to LLM error types
+   */
+  protected mapError(error: unknown): Error {
+    if (!(error instanceof Error)) {
+      return new LLMStreamError(String(error), 'openai');
+    }
+
+    const message = error.message.toLowerCase();
+
+    // Network errors
+    if (message.includes('fetch') || message.includes('network')) {
+      return new LLMStreamError(
+        'Network error. Please check your connection.',
+        'openai'
+      );
+    }
+
+    return new LLMStreamError(error.message, 'openai');
+  }
+}