tlc-claude-code 1.4.9 → 1.5.2

package/server/lib/litellm-client.js

@@ -0,0 +1,232 @@
+/**
+ * LiteLLM Client Module
+ *
+ * Client for interacting with LiteLLM proxy
+ */
+
+/**
+ * Create a LiteLLM client
+ * @param {Object} options - Client options
+ * @param {string} options.baseUrl - LiteLLM proxy URL
+ * @param {string} [options.apiKey] - API key for authentication
+ * @returns {Object} Client instance
+ */
+function createClient(options) {
+  const { baseUrl, apiKey } = options;
+
+  return {
+    baseUrl,
+    apiKey,
+    _fetch: globalThis.fetch,
+  };
+}
+
+/**
+ * Make a completion request
+ * @param {Object} client - Client instance
+ * @param {Object} options - Completion options
+ * @param {string} options.model - Model to use
+ * @param {string} options.prompt - Input prompt
+ * @param {number} [options.maxTokens] - Maximum tokens
+ * @param {number} [options.temperature] - Temperature
+ * @returns {Promise<Object>} Completion response
+ */
+async function completion(client, options) {
+  const { model, prompt, maxTokens, temperature } = options;
+
+  const body = {
+    model,
+    prompt,
+  };
+
+  if (maxTokens) body.max_tokens = maxTokens;
+  if (temperature !== undefined) body.temperature = temperature;
+
+  const response = await client._fetch(`${client.baseUrl}/v1/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(client.apiKey && { 'Authorization': `Bearer ${client.apiKey}` }),
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Completion failed: ${error}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Make a chat completion request
+ * @param {Object} client - Client instance
+ * @param {Object} options - Chat options
+ * @param {string} options.model - Model to use
+ * @param {Array} options.messages - Chat messages
+ * @param {boolean} [options.stream] - Enable streaming
+ * @param {number} [options.maxTokens] - Maximum tokens
+ * @param {number} [options.temperature] - Temperature
+ * @returns {Promise<Object>} Chat response
+ */
+async function chat(client, options) {
+  const { model, messages, stream, maxTokens, temperature } = options;
+
+  const body = {
+    model,
+    messages,
+    stream: stream || false,
+  };
+
+  if (maxTokens) body.max_tokens = maxTokens;
+  if (temperature !== undefined) body.temperature = temperature;
+
+  const response = await client._fetch(`${client.baseUrl}/v1/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(client.apiKey && { 'Authorization': `Bearer ${client.apiKey}` }),
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Chat failed: ${error}`);
+  }
+
+  if (stream && response.body) {
+    return { stream: response.body };
+  }
+
+  return response.json();
+}
+
+/**
+ * Get usage statistics
+ * @param {Object} client - Client instance
+ * @param {Object} [options] - Query options
+ * @param {string} [options.startDate] - Start date
+ * @param {string} [options.endDate] - End date
+ * @returns {Promise<Object>} Usage statistics
+ */
+async function getUsage(client, options = {}) {
+  const { startDate, endDate } = options;
+
+  let url = `${client.baseUrl}/spend/logs`;
+  const params = new URLSearchParams();
+
+  if (startDate) params.set('start_date', startDate);
+  if (endDate) params.set('end_date', endDate);
+
+  if (params.toString()) {
+    url += `?${params.toString()}`;
+  }
+
+  const response = await client._fetch(url, {
+    headers: {
+      ...(client.apiKey && { 'Authorization': `Bearer ${client.apiKey}` }),
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch usage');
+  }
+
+  return response.json();
+}
+
+/**
+ * Get available models
+ * @param {Object} client - Client instance
+ * @returns {Promise<Array>} List of models
+ */
+async function getModels(client) {
+  const response = await client._fetch(`${client.baseUrl}/v1/models`, {
+    headers: {
+      ...(client.apiKey && { 'Authorization': `Bearer ${client.apiKey}` }),
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error('Failed to fetch models');
+  }
+
+  const result = await response.json();
+  return result.data || [];
+}
+
+/**
+ * Check proxy health
+ * @param {Object} client - Client instance
+ * @returns {Promise<Object>} Health status
+ */
+async function healthCheck(client) {
+  try {
+    const response = await client._fetch(`${client.baseUrl}/health`, {
+      headers: {
+        ...(client.apiKey && { 'Authorization': `Bearer ${client.apiKey}` }),
+      },
+    });
+
+    if (!response.ok) {
+      return { status: 'unhealthy', error: 'Bad response' };
+    }
+
+    const result = await response.json();
+    return { status: result.status || 'healthy', ...result };
+  } catch (error) {
+    return { status: 'unhealthy', error: error.message };
+  }
+}
+
+/**
+ * Set API key
+ * @param {Object} client - Client instance
+ * @param {string} apiKey - New API key
+ */
+function setApiKey(client, apiKey) {
+  client.apiKey = apiKey;
+}
+
+/**
+ * Execute request with fallback
+ * @param {Object} client - Client instance
+ * @param {Object} options - Fallback options
+ * @param {string} options.primary - Primary model
+ * @param {string[]} options.fallbacks - Fallback models
+ * @param {Object} options.request - Request options
+ * @returns {Promise<Object>} Response
+ */
+async function withFallback(client, options) {
+  const { primary, fallbacks, request } = options;
+
+  const models = [primary, ...fallbacks];
+  const errors = [];
+
+  for (const model of models) {
+    try {
+      const result = await completion(client, {
+        ...request,
+        model,
+      });
+      return result;
+    } catch (error) {
+      errors.push({ model, error: error.message });
+    }
+  }
+
+  throw new Error(`All models failed: ${errors.map(e => `${e.model}: ${e.error}`).join(', ')}`);
+}
+
+module.exports = {
+  createClient,
+  completion,
+  chat,
+  getUsage,
+  getModels,
+  healthCheck,
+  setApiKey,
+  withFallback,
+};

package/server/lib/litellm-client.test.js

@@ -0,0 +1,267 @@
+/**
+ * LiteLLM Client Tests
+ *
+ * Client for interacting with LiteLLM proxy
+ */
+
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  createClient,
+  completion,
+  chat,
+  getUsage,
+  getModels,
+  healthCheck,
+  setApiKey,
+  withFallback,
+} = require('./litellm-client.js');
+
+describe('LiteLLM Client', () => {
+  let client;
+
+  beforeEach(() => {
+    client = createClient({
+      baseUrl: 'http://localhost:4000',
+    });
+  });
+
+  describe('createClient', () => {
+    it('creates client with base URL', () => {
+      assert.ok(client);
+      assert.strictEqual(client.baseUrl, 'http://localhost:4000');
+    });
+
+    it('accepts API key', () => {
+      const clientWithKey = createClient({
+        baseUrl: 'http://localhost:4000',
+        apiKey: 'test-key',
+      });
+
+      assert.ok(clientWithKey.apiKey);
+    });
+  });
+
+  describe('completion', () => {
+    it('sends completion request', async () => {
+      // Mock the fetch for testing
+      client._fetch = async (url, options) => ({
+        ok: true,
+        json: async () => ({
+          choices: [{ text: 'Hello world' }],
+          usage: { prompt_tokens: 10, completion_tokens: 5 },
+        }),
+      });
+
+      const result = await completion(client, {
+        model: 'claude-3-sonnet',
+        prompt: 'Say hello',
+      });
+
+      assert.ok(result.choices);
+      assert.strictEqual(result.choices[0].text, 'Hello world');
+    });
+
+    it('includes usage stats', async () => {
+      client._fetch = async () => ({
+        ok: true,
+        json: async () => ({
+          choices: [{ text: 'Response' }],
+          usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
+        }),
+      });
+
+      const result = await completion(client, {
+        model: 'claude-3-sonnet',
+        prompt: 'Test',
+      });
+
+      assert.ok(result.usage);
+      assert.strictEqual(result.usage.total_tokens, 15);
+    });
+  });
+
+  describe('chat', () => {
+    it('sends chat request', async () => {
+      client._fetch = async () => ({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { role: 'assistant', content: 'Hello!' } }],
+          usage: { prompt_tokens: 10, completion_tokens: 5 },
+        }),
+      });
+
+      const result = await chat(client, {
+        model: 'claude-3-sonnet',
+        messages: [{ role: 'user', content: 'Hi' }],
+      });
+
+      assert.ok(result.choices);
+      assert.strictEqual(result.choices[0].message.content, 'Hello!');
+    });
+
+    it('handles streaming', async () => {
+      let chunks = [];
+      client._fetch = async () => ({
+        ok: true,
+        body: {
+          getReader: () => ({
+            read: async () => {
+              if (chunks.length < 3) {
+                chunks.push({ content: 'chunk' });
+                return { done: false, value: new TextEncoder().encode('data: {"choices":[{"delta":{"content":"chunk"}}]}\n\n') };
+              }
+              return { done: true };
+            },
+          }),
+        },
+      });
+
+      const result = await chat(client, {
+        model: 'claude-3-sonnet',
+        messages: [{ role: 'user', content: 'Hi' }],
+        stream: true,
+      });
+
+      assert.ok(result.stream || result.choices);
+    });
+  });
+
+  describe('getUsage', () => {
+    it('returns usage statistics', async () => {
+      client._fetch = async () => ({
+        ok: true,
+        json: async () => ({
+          total_spend: 15.50,
+          total_tokens: 50000,
+          by_model: {
+            'claude-3-sonnet': { spend: 10.00, tokens: 30000 },
+            'gpt-4': { spend: 5.50, tokens: 20000 },
+          },
+        }),
+      });
+
+      const usage = await getUsage(client);
+
+      assert.ok(usage.total_spend >= 0);
+      assert.ok(usage.by_model);
+    });
+
+    it('filters by date range', async () => {
+      let capturedOptions;
+      client._fetch = async (url, options) => {
+        capturedOptions = { url };
+        return {
+          ok: true,
+          json: async () => ({ total_spend: 5.00, by_model: {} }),
+        };
+      };
+
+      await getUsage(client, {
+        startDate: '2025-01-01',
+        endDate: '2025-01-31',
+      });
+
+      assert.ok(capturedOptions.url.includes('start') || capturedOptions.url.includes('2025'));
+    });
+  });
+
+  describe('getModels', () => {
+    it('lists available models', async () => {
+      client._fetch = async () => ({
+        ok: true,
+        json: async () => ({
+          data: [
+            { id: 'claude-3-opus', provider: 'anthropic' },
+            { id: 'gpt-4', provider: 'openai' },
+          ],
+        }),
+      });
+
+      const models = await getModels(client);
+
+      assert.ok(Array.isArray(models));
+      assert.ok(models.length > 0);
+    });
+  });
+
+  describe('healthCheck', () => {
+    it('returns healthy status', async () => {
+      client._fetch = async () => ({
+        ok: true,
+        json: async () => ({ status: 'healthy' }),
+      });
+
+      const health = await healthCheck(client);
+
+      assert.strictEqual(health.status, 'healthy');
+    });
+
+    it('returns unhealthy on error', async () => {
+      client._fetch = async () => {
+        throw new Error('Connection refused');
+      };
+
+      const health = await healthCheck(client);
+
+      assert.strictEqual(health.status, 'unhealthy');
+    });
+  });
+
+  describe('setApiKey', () => {
+    it('updates API key', () => {
+      setApiKey(client, 'new-key');
+
+      assert.strictEqual(client.apiKey, 'new-key');
+    });
+  });
+
+  describe('withFallback', () => {
+    it('tries fallback on primary failure', async () => {
+      let attempts = [];
+      client._fetch = async (url, options) => {
+        const body = JSON.parse(options.body);
+        attempts.push(body.model);
+
+        if (body.model === 'claude-3-opus') {
+          throw new Error('Rate limited');
+        }
+
+        return {
+          ok: true,
+          json: async () => ({
+            choices: [{ text: 'Response from fallback' }],
+          }),
+        };
+      };
+
+      const result = await withFallback(client, {
+        primary: 'claude-3-opus',
+        fallbacks: ['claude-3-sonnet', 'gpt-4'],
+        request: { prompt: 'Test' },
+      });
+
+      assert.ok(attempts.includes('claude-3-opus'));
+      assert.ok(attempts.includes('claude-3-sonnet'));
+      assert.ok(result.choices);
+    });
+
+    it('returns error if all models fail', async () => {
+      client._fetch = async () => {
+        throw new Error('All models unavailable');
+      };
+
+      try {
+        await withFallback(client, {
+          primary: 'claude-3-opus',
+          fallbacks: ['claude-3-sonnet'],
+          request: { prompt: 'Test' },
+        });
+        assert.fail('Should have thrown');
+      } catch (err) {
+        assert.ok(err.message.includes('unavailable') || err.message.includes('failed'));
+      }
+    });
+  });
+});