@liquidmetal-ai/precip 1.0.0

package/src/engine/llm-provider.test.ts

@@ -0,0 +1,275 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createLLMProvider } from './llm-provider.js';
+
+describe('LLM Provider Retry Logic', () => {
+  describe('resolveRetryConfig validation', () => {
+    it('clamps negative maxRetries to 0', () => {
+      const logger = vi.fn();
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        { maxRetries: -5 }
+      );
+
+      expect(provider).toBeDefined();
+    });
+
+    it('clamps negative initialDelayMs to 0', () => {
+      const logger = vi.fn();
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        { initialDelayMs: -1000 }
+      );
+
+      expect(provider).toBeDefined();
+    });
+
+    it('clamps backoffMultiplier to minimum 1', () => {
+      const logger = vi.fn();
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        { backoffMultiplier: 0.5 }
+      );
+
+      expect(provider).toBeDefined();
+    });
+
+    it('ensures maxDelayMs is at least initialDelayMs', () => {
+      const logger = vi.fn();
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        { initialDelayMs: 5000, maxDelayMs: 1000 }
+      );
+
+      expect(provider).toBeDefined();
+    });
+
+    it('fills in all defaults when config is empty', () => {
+      const logger = vi.fn();
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        {}
+      );
+
+      expect(provider).toBeDefined();
+    });
+  });
+
+  describe('retry behavior', () => {
+    it('retries on transient errors with exponential backoff', async () => {
+      const logger = {
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        {
+          maxRetries: 2,
+          initialDelayMs: 100,
+          backoffMultiplier: 2,
+          maxDelayMs: 500,
+        }
+      );
+
+      // Mock fetch to fail twice then succeed
+      let attemptCount = 0;
+      global.fetch = vi.fn().mockImplementation(() => {
+        attemptCount++;
+        if (attemptCount < 3) {
+          return Promise.reject(new Error('Network error'));
+        }
+        return Promise.resolve({
+          ok: true,
+          body: new ReadableStream(),
+          json: async () => ({ choices: [{ message: { content: 'success' } }] }),
+        } as Response);
+      });
+
+      try {
+        await provider.chat([{ role: 'user', content: 'test' }]);
+      } catch (_error) {
+        // Expected to fail since we're not properly mocking the stream
+      }
+
+      // Verify retry attempts
+      expect(attemptCount).toBe(3);
+      expect(logger.warn).toHaveBeenCalledTimes(2);
+    });
+
+    it('respects maxRetries limit', async () => {
+      const logger = {
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        {
+          maxRetries: 2,
+          initialDelayMs: 10,
+          backoffMultiplier: 2,
+        }
+      );
+
+      let attemptCount = 0;
+      global.fetch = vi.fn().mockImplementation(() => {
+        attemptCount++;
+        return Promise.reject(new Error('Always fails'));
+      });
+
+      try {
+        await provider.chat([{ role: 'user', content: 'test' }]);
+      } catch (_error) {
+        // Expected
+      }
+
+      // Should attempt initial call + 2 retries = 3 total
+      expect(attemptCount).toBe(3);
+      expect(logger.warn).toHaveBeenCalledTimes(2);
+    });
+
+    it('filters errors with retryOn predicate', async () => {
+      const logger = {
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        {
+          maxRetries: 5,
+          initialDelayMs: 10,
+          retryOn: (error) => {
+            // Only retry on network errors, not auth errors
+            return error.message.includes('Network');
+          },
+        }
+      );
+
+      let attemptCount = 0;
+      global.fetch = vi.fn().mockImplementation(() => {
+        attemptCount++;
+        return Promise.reject(new Error('Auth error'));
+      });
+
+      try {
+        await provider.chat([{ role: 'user', content: 'test' }]);
+      } catch (_error) {
+        // Expected
+      }
+
+      // Should not retry because retryOn returns false
+      expect(attemptCount).toBe(1);
+      expect(logger.warn).not.toHaveBeenCalled();
+    });
+
+    it('respects maxRetries=0 (no retries)', async () => {
+      const logger = {
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+        },
+        logger,
+        {
+          maxRetries: 0,
+          initialDelayMs: 10,
+        }
+      );
+
+      let attemptCount = 0;
+      global.fetch = vi.fn().mockImplementation(() => {
+        attemptCount++;
+        return Promise.reject(new Error('Network error'));
+      });
+
+      try {
+        await provider.chat([{ role: 'user', content: 'test' }]);
+      } catch (_error) {
+        // Expected
+      }
+
+      // Should only attempt once (no retries)
+      expect(attemptCount).toBe(1);
+      expect(logger.warn).not.toHaveBeenCalled();
+    });
+
+    it('succeeds on first attempt when no error', async () => {
+      const logger = {
+        warn: vi.fn(),
+        error: vi.fn(),
+      };
+
+      const provider = createLLMProvider(
+        {
+          provider: 'openai',
+          apiKey: 'test-key',
+          model: 'gpt-4',
+          streaming: false,
+        },
+        logger,
+        {
+          maxRetries: 2,
+          initialDelayMs: 10,
+        }
+      );
+
+      global.fetch = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'success' } }],
+        }),
+      } as Response);
+
+      const result = await provider.chat([{ role: 'user', content: 'test' }]);
+
+      expect(result.content).toBe('success');
+      expect(logger.warn).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/engine/llm-provider.ts

@@ -0,0 +1,330 @@
+/**
+ * LLM Provider Abstraction
+ * Supports OpenAI, Anthropic, GLM, and Raindrop AI
+ */
+
+import type { LLMConfig, LLMMessage, LLMResponse, LLMToolCall, Logger, RetryConfig } from '../types.js';
+import { parseOpenAIStream, parseOpenAIResponse } from './stream-parser.js';
+
+export interface LLMProvider {
+  chat(messages: LLMMessage[], tools?: any[]): Promise<LLMResponse>;
+}
+
+// ============================================================================
+// Retry Helper
+// ============================================================================
+
+/** Resolved retry config with all defaults filled in */
+interface ResolvedRetryConfig {
+  maxRetries: number;
+  initialDelayMs: number;
+  backoffMultiplier: number;
+  maxDelayMs: number;
+  retryOn: (error: Error) => boolean;
+}
+
+/** Fill in defaults for retry config */
+function resolveRetryConfig(config?: RetryConfig): ResolvedRetryConfig | null {
+  if (!config) return null;
+
+  const maxRetries = Math.max(0, config.maxRetries ?? 2);
+  const initialDelayMs = Math.max(0, config.initialDelayMs ?? 1000);
+  const backoffMultiplier = Math.max(1, config.backoffMultiplier ?? 2);
+  const maxDelayMs = Math.max(initialDelayMs, config.maxDelayMs ?? 30000);
+
+  return {
+    maxRetries,
+    initialDelayMs,
+    backoffMultiplier,
+    maxDelayMs,
+    retryOn: config.retryOn ?? (() => true),
+  };
+}
+
+/**
+ * Execute an async function with retry and exponential backoff.
+ * Only retries if `retryOn` returns true for the caught error.
+ */
+async function withRetry<T>(
+  fn: () => Promise<T>,
+  config: ResolvedRetryConfig,
+  logger?: Logger,
+): Promise<T> {
+  let lastError: Error;
+  let delay = config.initialDelayMs;
+
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+
+      if (attempt >= config.maxRetries || !config.retryOn(lastError)) {
+        throw lastError;
+      }
+
+      logger?.warn?.('LLM call failed, retrying', {
+        attempt: attempt + 1,
+        maxRetries: config.maxRetries,
+        delayMs: delay,
+        error: lastError.message,
+      });
+
+      await new Promise((r) => setTimeout(r, delay));
+      delay = Math.min(delay * config.backoffMultiplier, config.maxDelayMs);
+    }
+  }
+
+  throw lastError!;
+}
+
+// ============================================================================
+// Provider Factory
+// ============================================================================
+
+/**
+ * Create an LLM provider instance based on config
+ */
+export function createLLMProvider(config: LLMConfig, logger?: Logger, retry?: RetryConfig): LLMProvider {
+  const retryConfig = resolveRetryConfig(retry);
+
+  let provider: LLMProvider;
+  switch (config.provider) {
+    case 'openai':
+      provider = new OpenAIProvider(config, logger);
+      break;
+
+    case 'anthropic':
+      provider = new AnthropicProvider(config, logger);
+      break;
+
+    case 'liquidmetal':
+      provider = new LiquidmetalProvider(config, logger);
+      break;
+
+    default:
+      throw new Error(`Unsupported LLM provider: ${config.provider}`);
+  }
+
+  // Wrap with retry if configured
+  if (retryConfig) {
+    return new RetryProvider(provider, retryConfig, logger);
+  }
+
+  return provider;
+}
+
+// ============================================================================
+// Retry Provider Wrapper
+// ============================================================================
+
+/**
+ * Wraps any LLM provider with retry logic.
+ * Transparent to the caller — just adds resilience.
+ */
+class RetryProvider implements LLMProvider {
+  constructor(
+    private inner: LLMProvider,
+    private retryConfig: ResolvedRetryConfig,
+    private logger?: Logger,
+  ) {}
+
+  async chat(messages: LLMMessage[], tools?: any[]): Promise<LLMResponse> {
+    return withRetry(
+      () => this.inner.chat(messages, tools),
+      this.retryConfig,
+      this.logger,
+    );
+  }
+}
+
+/**
+ * OpenAI Provider (GPT-4, GPT-3.5, etc.)
+ */
+class OpenAIProvider implements LLMProvider {
+  constructor(
+    private config: LLMConfig,
+    private logger?: Logger
+  ) {}
+
+  async chat(messages: LLMMessage[], tools?: any[]): Promise<LLMResponse> {
+    const baseUrl = this.config.baseUrl || 'https://api.openai.com/v1';
+
+    const payload: any = {
+      model: this.config.model,
+      messages,
+      temperature: this.config.temperature ?? 0.7,
+      max_tokens: this.config.maxTokens ?? 4096,
+      stream: this.config.streaming ?? true
+    };
+
+    if (tools && tools.length > 0) {
+      payload.tools = tools;
+      payload.tool_choice = 'auto';
+    }
+
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${this.config.apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${error}`);
+    }
+
+    if (this.config.streaming) {
+      return await parseOpenAIStream(response.body!, this.logger);
+    } else {
+      const data = await response.json();
+      return parseOpenAIResponse(data);
+    }
+  }
+}
+
+/**
+ * Anthropic Provider (Claude)
+ */
+class AnthropicProvider implements LLMProvider {
+  constructor(
+    private config: LLMConfig,
+    private logger?: Logger
+  ) {}
+
+  async chat(messages: LLMMessage[], tools?: any[]): Promise<LLMResponse> {
+    const baseUrl = this.config.baseUrl || 'https://api.anthropic.com/v1';
+
+    // Extract system message
+    const systemMessage = messages.find(m => m.role === 'system')?.content || '';
+    const conversationMessages = messages.filter(m => m.role !== 'system');
+
+    const payload: any = {
+      model: this.config.model,
+      messages: conversationMessages,
+      system: systemMessage,
+      max_tokens: this.config.maxTokens ?? 4096,
+      temperature: this.config.temperature ?? 0.7,
+      stream: this.config.streaming ?? true
+    };
+
+    if (tools && tools.length > 0) {
+      payload.tools = tools.map((t: any) => ({
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters
+      }));
+    }
+
+    const response = await fetch(`${baseUrl}/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.config.apiKey!,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify(payload)
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} ${error}`);
+    }
+
+    const data: any = await response.json();
+
+    // Parse Anthropic response
+    const toolCalls: LLMToolCall[] = [];
+    let content = '';
+
+    for (const block of data.content || []) {
+      if (block.type === 'text') {
+        content += block.text;
+      } else if (block.type === 'tool_use') {
+        toolCalls.push({
+          id: block.id,
+          type: 'function',
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input)
+          }
+        });
+      }
+    }
+
+    return {
+      content: content || null,
+      toolCalls,
+      finishReason: data.stop_reason || null,
+      usage: data.usage
+        ? {
+            promptTokens: data.usage.input_tokens,
+            completionTokens: data.usage.output_tokens,
+            totalTokens: data.usage.input_tokens + data.usage.output_tokens
+          }
+        : undefined
+    };
+  }
+}
+
+/**
+ * LiquidMetal AI Provider (for Raindrop AI binding)
+ */
+class LiquidmetalProvider implements LLMProvider {
+  private aiBinding: any;
+
+  constructor(
+    private config: LLMConfig,
+    private logger?: Logger
+  ) {
+    // AI binding should be passed via baseUrl (hacky but works)
+    this.aiBinding = (config as any).aiBinding;
+    if (!this.aiBinding) {
+      throw new Error('Liquidmetal provider requires AI binding. Pass it via config.aiBinding');
+    }
+  }
+
+  async chat(messages: LLMMessage[], tools?: any[]): Promise<LLMResponse> {
+    const payload: any = {
+      messages,
+      temperature: this.config.temperature ?? 0.7,
+      max_tokens: this.config.maxTokens ?? 4096,
+      stream: this.config.streaming ?? true
+    };
+
+    if (tools && tools.length > 0) {
+      payload.tools = tools;
+      payload.tool_choice = 'auto';
+    }
+
+    let result: any;
+    try {
+      // Use Liquidmetal AI binding
+      result = await this.aiBinding.run(this.config.model, payload);
+    } catch (error) {
+      this.logger?.error?.('AI binding error', {
+        error: (error as Error).message,
+        stack: (error as Error).stack
+      });
+      throw new Error(`AI binding failed: ${(error as Error).message}`);
+    }
+
+    // Check if we got an error response
+    if (result?.error) {
+      const errorMsg =
+        typeof result.error === 'string' ? result.error : JSON.stringify(result.error);
+      this.logger?.error?.('AI returned error response', { error: errorMsg });
+      throw new Error(`AI service error: ${errorMsg}`);
+    }
+
+    // Check if streaming
+    if (result instanceof ReadableStream) {
+      return await parseOpenAIStream(result, this.logger, true);
+    } else {
+      return parseOpenAIResponse(result);
+    }
+  }
+}