tlc-claude-code 1.4.9 → 1.5.2

package/server/lib/litellm-config.js

@@ -0,0 +1,273 @@
+/**
+ * LiteLLM Config Module
+ *
+ * Configuration management for LiteLLM proxy
+ */
+
+const DEFAULT_BASE_URL = 'http://localhost:4000';
+
+/**
+ * Create a new LiteLLM configuration
+ * @returns {Object} Configuration object
+ */
+function createConfig() {
+  return {
+    baseUrl: DEFAULT_BASE_URL,
+    models: {},
+    fallbacks: {},
+    spendLimits: {
+      daily: null,
+      monthly: null,
+      byModel: {},
+      byUser: {},
+    },
+    cache: {
+      enabled: false,
+      ttl: 3600,
+    },
+  };
+}
+
+/**
+ * Set a model alias
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Alias options
+ * @param {string} options.alias - Logical name
+ * @param {string} options.provider - Provider name
+ * @param {string} options.model - Model identifier
+ */
+function setModelAlias(config, options) {
+  const { alias, provider, model } = options;
+
+  config.models[alias] = {
+    provider,
+    model,
+  };
+}
+
+/**
+ * Get a model alias
+ * @param {Object} config - Configuration object
+ * @param {string} alias - Logical name
+ * @returns {Object|null} Model configuration or null
+ */
+function getModelAlias(config, alias) {
+  return config.models[alias] || null;
+}
+
+/**
+ * Set fallback chain for a model
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Fallback options
+ * @param {string} options.primary - Primary model
+ * @param {string[]} options.fallbacks - Ordered fallback models
+ */
+function setFallbackChain(config, options) {
+  const { primary, fallbacks } = options;
+
+  config.fallbacks[primary] = fallbacks;
+}
+
+/**
+ * Get fallback chain for a model
+ * @param {Object} config - Configuration object
+ * @param {string} model - Model name
+ * @returns {string[]} Fallback models
+ */
+function getFallbackChain(config, model) {
+  return config.fallbacks[model] || [];
+}
+
+/**
+ * Set spend limit
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Limit options
+ * @param {string} options.type - Limit type: 'daily', 'monthly', 'model', 'user'
+ * @param {number} options.limit - Limit amount in dollars
+ * @param {string} [options.model] - Model name (for model limits)
+ * @param {string} [options.user] - User identifier (for user limits)
+ */
+function setSpendLimit(config, options) {
+  const { type, limit, model, user } = options;
+
+  if (type === 'daily') {
+    config.spendLimits.daily = limit;
+  } else if (type === 'monthly') {
+    config.spendLimits.monthly = limit;
+  } else if (type === 'model' && model) {
+    config.spendLimits.byModel[model] = limit;
+  } else if (type === 'user' && user) {
+    config.spendLimits.byUser[user] = limit;
+  }
+}
+
+/**
+ * Get spend limit
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Query options
+ * @param {string} options.type - Limit type
+ * @param {string} [options.model] - Model name
+ * @param {string} [options.user] - User identifier
+ * @returns {number|null} Limit or null
+ */
+function getSpendLimit(config, options) {
+  const { type, model, user } = options;
+
+  if (type === 'daily') {
+    return config.spendLimits.daily;
+  } else if (type === 'monthly') {
+    return config.spendLimits.monthly;
+  } else if (type === 'model' && model) {
+    return config.spendLimits.byModel[model] || null;
+  } else if (type === 'user' && user) {
+    return config.spendLimits.byUser[user] || null;
+  }
+
+  return null;
+}
+
+/**
+ * Set base URL for LiteLLM proxy
+ * @param {Object} config - Configuration object
+ * @param {string} url - Base URL
+ */
+function setBaseUrl(config, url) {
+  config.baseUrl = url;
+}
+
+/**
+ * Get base URL for LiteLLM proxy
+ * @param {Object} config - Configuration object
+ * @returns {string} Base URL
+ */
+function getBaseUrl(config) {
+  return config.baseUrl;
+}
+
+/**
+ * Enable response caching
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Cache options
+ * @param {number} [options.ttl=3600] - Cache TTL in seconds
+ */
+function enableCache(config, options = {}) {
+  config.cache.enabled = true;
+  config.cache.ttl = options.ttl || 3600;
+}
+
+/**
+ * Disable response caching
+ * @param {Object} config - Configuration object
+ */
+function disableCache(config) {
+  config.cache.enabled = false;
+}
+
+/**
+ * Check if caching is enabled
+ * @param {Object} config - Configuration object
+ * @returns {boolean} Cache enabled status
+ */
+function isCacheEnabled(config) {
+  return config.cache.enabled;
+}
+
+/**
+ * Export configuration
+ * @param {Object} config - Configuration object
+ * @param {Object} options - Export options
+ * @param {string} [options.format='json'] - Export format: 'json' or 'yaml'
+ * @returns {string} Exported configuration
+ */
+function exportConfig(config, options = {}) {
+  const { format = 'json' } = options;
+
+  if (format === 'yaml') {
+    // Simple YAML export (no external dependencies)
+    const lines = [];
+    lines.push(`base_url: "${config.baseUrl}"`);
+    lines.push('');
+    lines.push('models:');
+    for (const [alias, model] of Object.entries(config.models)) {
+      lines.push(`  ${alias}:`);
+      lines.push(`    provider: "${model.provider}"`);
+      lines.push(`    model: "${model.model}"`);
+    }
+    lines.push('');
+    lines.push('fallbacks:');
+    for (const [primary, fallbacks] of Object.entries(config.fallbacks)) {
+      lines.push(`  ${primary}: [${fallbacks.map(f => `"${f}"`).join(', ')}]`);
+    }
+    lines.push('');
+    lines.push('spend_limits:');
+    if (config.spendLimits.daily !== null) {
+      lines.push(`  daily: ${config.spendLimits.daily}`);
+    }
+    if (config.spendLimits.monthly !== null) {
+      lines.push(`  monthly: ${config.spendLimits.monthly}`);
+    }
+    lines.push('');
+    lines.push('cache:');
+    lines.push(`  enabled: ${config.cache.enabled}`);
+    lines.push(`  ttl: ${config.cache.ttl}`);
+
+    return lines.join('\n');
+  }
+
+  return JSON.stringify(config, null, 2);
+}
+
+/**
+ * Import configuration
+ * @param {string} data - Configuration data
+ * @param {Object} options - Import options
+ * @param {string} [options.format='json'] - Import format
+ * @returns {Object} Configuration object
+ */
+function importConfig(data, options = {}) {
+  const { format = 'json' } = options;
+
+  if (format === 'json') {
+    const imported = JSON.parse(data);
+    const config = createConfig();
+
+    if (imported.models) {
+      config.models = imported.models;
+    }
+    if (imported.fallbacks) {
+      config.fallbacks = imported.fallbacks;
+    }
+    if (imported.baseUrl) {
+      config.baseUrl = imported.baseUrl;
+    }
+    if (imported.spendLimits) {
+      config.spendLimits = { ...config.spendLimits, ...imported.spendLimits };
+    }
+    if (imported.cache) {
+      config.cache = { ...config.cache, ...imported.cache };
+    }
+
+    return config;
+  }
+
+  // For YAML, we'd need a parser - return default config
+  return createConfig();
+}
+
+module.exports = {
+  createConfig,
+  setModelAlias,
+  getModelAlias,
+  setFallbackChain,
+  getFallbackChain,
+  setSpendLimit,
+  getSpendLimit,
+  setBaseUrl,
+  getBaseUrl,
+  enableCache,
+  disableCache,
+  isCacheEnabled,
+  exportConfig,
+  importConfig,
+  DEFAULT_BASE_URL,
+};

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

@@ -0,0 +1,212 @@
+/**
+ * LiteLLM Config Tests
+ *
+ * Configuration management for LiteLLM proxy
+ */
+
+const { describe, it, beforeEach } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  createConfig,
+  setModelAlias,
+  getModelAlias,
+  setFallbackChain,
+  getFallbackChain,
+  setSpendLimit,
+  getSpendLimit,
+  setBaseUrl,
+  getBaseUrl,
+  enableCache,
+  disableCache,
+  isCacheEnabled,
+  exportConfig,
+  importConfig,
+} = require('./litellm-config.js');
+
+describe('LiteLLM Config', () => {
+  let config;
+
+  beforeEach(() => {
+    config = createConfig();
+  });
+
+  describe('createConfig', () => {
+    it('creates default config', () => {
+      assert.ok(config);
+      assert.ok(config.models);
+      assert.ok(config.fallbacks);
+    });
+
+    it('has default base URL', () => {
+      const baseUrl = getBaseUrl(config);
+      assert.ok(baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1'));
+    });
+  });
+
+  describe('setModelAlias', () => {
+    it('maps logical name to provider model', () => {
+      setModelAlias(config, {
+        alias: 'fast',
+        provider: 'anthropic',
+        model: 'claude-3-haiku-20240307',
+      });
+
+      const resolved = getModelAlias(config, 'fast');
+      assert.strictEqual(resolved.provider, 'anthropic');
+      assert.strictEqual(resolved.model, 'claude-3-haiku-20240307');
+    });
+
+    it('supports multiple aliases', () => {
+      setModelAlias(config, { alias: 'fast', provider: 'anthropic', model: 'claude-3-haiku-20240307' });
+      setModelAlias(config, { alias: 'smart', provider: 'anthropic', model: 'claude-3-opus-20240229' });
+
+      assert.ok(getModelAlias(config, 'fast'));
+      assert.ok(getModelAlias(config, 'smart'));
+    });
+  });
+
+  describe('getModelAlias', () => {
+    it('returns null for unknown alias', () => {
+      const resolved = getModelAlias(config, 'nonexistent');
+      assert.strictEqual(resolved, null);
+    });
+
+    it('resolves nested aliases', () => {
+      setModelAlias(config, { alias: 'default', provider: 'anthropic', model: 'claude-3-sonnet-20240229' });
+
+      const resolved = getModelAlias(config, 'default');
+      assert.ok(resolved);
+    });
+  });
+
+  describe('setFallbackChain', () => {
+    it('sets ordered fallback models', () => {
+      setFallbackChain(config, {
+        primary: 'claude-3-opus',
+        fallbacks: ['claude-3-sonnet', 'gpt-4', 'gemini-pro'],
+      });
+
+      const chain = getFallbackChain(config, 'claude-3-opus');
+      assert.deepStrictEqual(chain, ['claude-3-sonnet', 'gpt-4', 'gemini-pro']);
+    });
+
+    it('allows empty fallback', () => {
+      setFallbackChain(config, {
+        primary: 'claude-3-haiku',
+        fallbacks: [],
+      });
+
+      const chain = getFallbackChain(config, 'claude-3-haiku');
+      assert.deepStrictEqual(chain, []);
+    });
+  });
+
+  describe('getFallbackChain', () => {
+    it('returns empty array for unknown model', () => {
+      const chain = getFallbackChain(config, 'unknown-model');
+      assert.deepStrictEqual(chain, []);
+    });
+  });
+
+  describe('setSpendLimit', () => {
+    it('sets daily spend limit', () => {
+      setSpendLimit(config, {
+        type: 'daily',
+        limit: 50.00,
+      });
+
+      const limit = getSpendLimit(config, { type: 'daily' });
+      assert.strictEqual(limit, 50.00);
+    });
+
+    it('sets per-model spend limit', () => {
+      setSpendLimit(config, {
+        type: 'model',
+        model: 'claude-3-opus',
+        limit: 100.00,
+      });
+
+      const limit = getSpendLimit(config, { type: 'model', model: 'claude-3-opus' });
+      assert.strictEqual(limit, 100.00);
+    });
+
+    it('sets per-user spend limit', () => {
+      setSpendLimit(config, {
+        type: 'user',
+        user: 'developer-1',
+        limit: 25.00,
+      });
+
+      const limit = getSpendLimit(config, { type: 'user', user: 'developer-1' });
+      assert.strictEqual(limit, 25.00);
+    });
+  });
+
+  describe('getSpendLimit', () => {
+    it('returns null for unset limit', () => {
+      const limit = getSpendLimit(config, { type: 'daily' });
+      assert.strictEqual(limit, null);
+    });
+  });
+
+  describe('setBaseUrl', () => {
+    it('updates proxy URL', () => {
+      setBaseUrl(config, 'http://litellm.example.com:4000');
+
+      const url = getBaseUrl(config);
+      assert.strictEqual(url, 'http://litellm.example.com:4000');
+    });
+  });
+
+  describe('enableCache', () => {
+    it('enables response caching', () => {
+      enableCache(config, { ttl: 3600 });
+
+      assert.strictEqual(isCacheEnabled(config), true);
+    });
+  });
+
+  describe('disableCache', () => {
+    it('disables response caching', () => {
+      enableCache(config, { ttl: 3600 });
+      disableCache(config);
+
+      assert.strictEqual(isCacheEnabled(config), false);
+    });
+  });
+
+  describe('exportConfig', () => {
+    it('exports as YAML string', () => {
+      setModelAlias(config, { alias: 'fast', provider: 'anthropic', model: 'claude-3-haiku-20240307' });
+
+      const yaml = exportConfig(config, { format: 'yaml' });
+
+      assert.ok(typeof yaml === 'string');
+      assert.ok(yaml.includes('fast'));
+    });
+
+    it('exports as JSON string', () => {
+      setModelAlias(config, { alias: 'fast', provider: 'anthropic', model: 'claude-3-haiku-20240307' });
+
+      const json = exportConfig(config, { format: 'json' });
+
+      const parsed = JSON.parse(json);
+      assert.ok(parsed.models);
+    });
+  });
+
+  describe('importConfig', () => {
+    it('imports from JSON', () => {
+      const jsonConfig = JSON.stringify({
+        models: { fast: { provider: 'openai', model: 'gpt-4' } },
+        baseUrl: 'http://custom:8000',
+      });
+
+      const imported = importConfig(jsonConfig, { format: 'json' });
+
+      assert.ok(imported.models);
+      assert.strictEqual(getBaseUrl(imported), 'http://custom:8000');
+    });
+  });
+});

package/server/lib/model-pricing.js

@@ -0,0 +1,189 @@
+/**
+ * Model Pricing Module
+ *
+ * Pricing database for all supported models
+ */
+
+const fs = require('fs');
+
+/**
+ * Default pricing for known models (per 1K tokens)
+ * Prices are approximate and should be updated regularly
+ */
+const DEFAULT_PRICING = {
+  // Anthropic Claude models
+  'claude-3-opus': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.075 },
+  'claude-3-sonnet': { inputPer1kTokens: 0.003, outputPer1kTokens: 0.015 },
+  'claude-3-haiku': { inputPer1kTokens: 0.00025, outputPer1kTokens: 0.00125 },
+  'claude-3.5-sonnet': { inputPer1kTokens: 0.003, outputPer1kTokens: 0.015 },
+  'claude-opus-4-5-20251101': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.075 },
+
+  // OpenAI models
+  'gpt-4': { inputPer1kTokens: 0.03, outputPer1kTokens: 0.06 },
+  'gpt-4-turbo': { inputPer1kTokens: 0.01, outputPer1kTokens: 0.03 },
+  'gpt-4o': { inputPer1kTokens: 0.005, outputPer1kTokens: 0.015 },
+  'gpt-3.5-turbo': { inputPer1kTokens: 0.0005, outputPer1kTokens: 0.0015 },
+  'o1': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.06 },
+  'o3': { inputPer1kTokens: 0.015, outputPer1kTokens: 0.06 },
+
+  // DeepSeek models
+  'deepseek-r1': { inputPer1kTokens: 0.00055, outputPer1kTokens: 0.00219 },
+  'deepseek-chat': { inputPer1kTokens: 0.00014, outputPer1kTokens: 0.00028 },
+  'deepseek-coder': { inputPer1kTokens: 0.00014, outputPer1kTokens: 0.00028 },
+
+  // Google Gemini models
+  'gemini-2.0-flash': { inputPer1kTokens: 0.00, outputPer1kTokens: 0.00 },
+  'gemini-1.5-pro': { inputPer1kTokens: 0.00125, outputPer1kTokens: 0.005 },
+  'gemini-1.5-flash': { inputPer1kTokens: 0.000075, outputPer1kTokens: 0.0003 },
+};
+
+// Runtime pricing (can be modified)
+let runtimePricing = { ...DEFAULT_PRICING };
+
+// Fallback rate for unknown models
+const FALLBACK_RATE = { inputPer1kTokens: 0.01, outputPer1kTokens: 0.03 };
+
+/**
+ * Get pricing for a model
+ * @param {string} model - Model name
+ * @returns {Object|null} Pricing object or null if unknown
+ */
+function getPricing(model) {
+  return runtimePricing[model] || null;
+}
+
+/**
+ * Calculate cost from token counts
+ * @param {Object} options - Calculation options
+ * @param {string} options.model - Model name
+ * @param {number} options.inputTokens - Input token count
+ * @param {number} options.outputTokens - Output token count
+ * @param {boolean} [options.isLocal] - Whether this is a local model
+ * @param {boolean} [options.useFallback=true] - Use fallback pricing for unknown
+ * @returns {number} Cost in dollars
+ */
+function calculateCost(options) {
+  const { model, inputTokens, outputTokens, isLocal, useFallback = true } = options;
+
+  // Local models are free
+  if (isLocal) {
+    return 0;
+  }
+
+  const pricing = getPricing(model);
+
+  if (!pricing) {
+    if (!useFallback) {
+      return 0;
+    }
+    // Use fallback rate
+    const inputCost = (inputTokens / 1000) * FALLBACK_RATE.inputPer1kTokens;
+    const outputCost = (outputTokens / 1000) * FALLBACK_RATE.outputPer1kTokens;
+    return inputCost + outputCost;
+  }
+
+  const inputCost = (inputTokens / 1000) * pricing.inputPer1kTokens;
+  const outputCost = (outputTokens / 1000) * pricing.outputPer1kTokens;
+
+  return inputCost + outputCost;
+}
+
+/**
+ * Load custom pricing from config file
+ * @param {string} filePath - Path to pricing config
+ * @param {Object} options - Options including fs module
+ * @returns {Object} Loaded pricing
+ */
+function loadPricing(filePath, options = {}) {
+  const fsModule = options.fs || fs;
+
+  if (!fsModule.existsSync(filePath)) {
+    return { ...DEFAULT_PRICING };
+  }
+
+  try {
+    const custom = JSON.parse(fsModule.readFileSync(filePath, 'utf-8'));
+    return { ...DEFAULT_PRICING, ...custom };
+  } catch (err) {
+    return { ...DEFAULT_PRICING };
+  }
+}
+
+/**
+ * Update pricing for a model at runtime
+ * @param {string} model - Model name
+ * @param {Object} pricing - Pricing object
+ * @param {number} pricing.inputPer1kTokens - Input cost per 1K tokens
+ * @param {number} pricing.outputPer1kTokens - Output cost per 1K tokens
+ */
+function updatePricing(model, pricing) {
+  runtimePricing[model] = pricing;
+}
+
+/**
+ * Get all default pricing
+ * @returns {Object} Default pricing for all models
+ */
+function getDefaultPricing() {
+  return { ...DEFAULT_PRICING };
+}
+
+/**
+ * Estimate cost using fallback rates
+ * @param {Object} options - Estimation options
+ * @param {string} options.model - Model name (may be unknown)
+ * @param {number} options.inputTokens - Input token count
+ * @param {number} options.outputTokens - Output token count
+ * @returns {number} Estimated cost
+ */
+function estimateCost(options) {
+  const { model, inputTokens, outputTokens } = options;
+
+  const pricing = getPricing(model) || FALLBACK_RATE;
+
+  const inputCost = (inputTokens / 1000) * pricing.inputPer1kTokens;
+  const outputCost = (outputTokens / 1000) * pricing.outputPer1kTokens;
+
+  return inputCost + outputCost;
+}
+
+/**
+ * Format cost as currency string
+ * @param {number} cost - Cost in dollars
+ * @returns {string} Formatted cost string
+ */
+function formatCost(cost) {
+  if (cost === 0) {
+    return '$0.00';
+  }
+
+  if (cost < 0.0001) {
+    return '<$0.0001';
+  }
+
+  if (cost < 0.01) {
+    return `$${cost.toFixed(4)}`;
+  }
+
+  return `$${cost.toFixed(2)}`;
+}
+
+/**
+ * Reset runtime pricing to defaults
+ */
+function resetPricing() {
+  runtimePricing = { ...DEFAULT_PRICING };
+}
+
+module.exports = {
+  getPricing,
+  calculateCost,
+  loadPricing,
+  updatePricing,
+  getDefaultPricing,
+  estimateCost,
+  formatCost,
+  resetPricing,
+  DEFAULT_PRICING,
+  FALLBACK_RATE,
+};