@meller/tokentalos 1.0.4 → 1.0.6

package/api/api/v1/usage.js

@@ -30,12 +30,12 @@ router.post('/ingest', authMiddleware, async (req, res) => {
   const totalTokens = (data.input_tokens || 0) + (data.output_tokens || 0);
   const calculator = getCostCalculator();
   const [inputCost, outputCost] = calculator.calculateCost(
-    provider, 
-    model, 
-    data.input_tokens || 0, 
+    provider,
+    model,
+    data.input_tokens || 0,
     data.output_tokens || 0
   );
-  
+
   const totalCost = inputCost + outputCost;
   const limitExceeded = totalTokens > (config.maxTokens || 32000);
 
@@ -46,7 +46,7 @@ router.post('/ingest', authMiddleware, async (req, res) => {
         input_cost, output_cost, total_cost, endpoint, latency_ms, token_limit_exceeded, timestamp
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `, [
-      usageId, orgId, projectId, 'ingested', provider, model, data.full_prompt || null, data.response_content || null, 
+      usageId, orgId, projectId, 'ingested', provider, model, data.full_prompt || null, data.response_content || null,
       data.input_tokens || 0, data.output_tokens || 0,
       totalTokens, inputCost, outputCost, totalCost, data.endpoint, data.latency_ms,
       limitExceeded ? 1 : 0, data.timestamp || new Date().toISOString()
@@ -58,12 +58,12 @@ router.post('/ingest', authMiddleware, async (req, res) => {
           INSERT INTO prompt_variables (usage_id, name, content, original_content, token_count, char_count, position)
           VALUES (?, ?, ?, ?, ?, ?, ?)
         `, [
-          usageId, 
-          v.name, 
-          v.content || '', 
+          usageId,
+          v.name,
+          v.content || '',
           v.original_content || v.content || '',
-          v.token_count || 0, 
-          v.char_count || 0, 
+          v.token_count || 0,
+          v.char_count || 0,
           v.position || 0
         ]);
 
@@ -87,10 +87,10 @@ router.post('/ingest', authMiddleware, async (req, res) => {
           INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
           VALUES (?, ?, ?, ?, ?)
         `, [
-          usageId, 
-          action.target, 
-          action.type, 
-          action.method || null, 
+          usageId,
+          action.target,
+          action.type,
+          action.method || null,
           JSON.stringify(action)
         ]);
       }
@@ -113,12 +113,12 @@ router.get('/recent', authMiddleware, async (req, res) => {
   try {
     let sql = 'SELECT * FROM usage_data WHERE org_id = ?';
     let params = [orgId];
-    
+
     if (projectId) {
       sql += ' AND project_id = ?';
       params.push(projectId);
     }
-    
+
     sql += ' ORDER BY timestamp DESC LIMIT ?';
     params.push(parseInt(limit));
 
@@ -130,7 +130,7 @@ router.get('/recent', authMiddleware, async (req, res) => {
         FROM prompt_variables 
         WHERE usage_id = ?
       `, [record.id]);
-      
+
       record.explain_plan = await db.get(`
         SELECT * FROM explain_plans WHERE usage_id = ?
       `, [record.id]);
@@ -139,13 +139,23 @@ router.get('/recent', authMiddleware, async (req, res) => {
         if (record.explain_plan.variable_analysis) record.explain_plan.variable_analysis = JSON.parse(record.explain_plan.variable_analysis);
         if (record.explain_plan.detected_issues) record.explain_plan.detected_issues = JSON.parse(record.explain_plan.detected_issues);
         if (record.explain_plan.optimization_suggestions) record.explain_plan.optimization_suggestions = JSON.parse(record.explain_plan.optimization_suggestions);
-        
+        if (record.explain_plan.mce_alternatives && typeof record.explain_plan.mce_alternatives === 'string') {
+          record.explain_plan.mce_alternatives = JSON.parse(record.explain_plan.mce_alternatives);
+        }
+
         // On-the-fly MCE calculation if missing from DB (for existing records)
-        if (!record.explain_plan.mce_best_alternative_model) {
+        if (!record.explain_plan.mce_best_alternative_model || !record.explain_plan.mce_alternatives) {
           const calculator = getCostCalculator();
           const bestAlt = calculator.getBestAlternative(record.provider, record.model, record.input_tokens, record.output_tokens);
+          const allAlts = calculator.getAllAlternatives(record.provider, record.model, record.input_tokens, record.output_tokens);
+
+          record.explain_plan.mce_alternatives = allAlts;
+
           if (bestAlt) {
-            const savingsPct = record.total_cost > 0 ? ((record.total_cost - bestAlt.cost) / record.total_cost) * 100 : 0;
+            // Use calculated cost from tokens (record.total_cost may be 0 for passively ingested records)
+            const [calcInput, calcOutput] = calculator.calculateCost(record.provider, record.model, record.input_tokens, record.output_tokens);
+            const currentCost = (calcInput + calcOutput) > 0 ? (calcInput + calcOutput) : (record.total_cost || 0);
+            const savingsPct = currentCost > 0 ? ((currentCost - bestAlt.cost) / currentCost) * 100 : 0;
             if (savingsPct > 10) {
               record.explain_plan.mce_best_alternative_model = bestAlt.model;
               record.explain_plan.mce_best_alternative_provider = bestAlt.provider;
@@ -169,7 +179,7 @@ router.post('/execute', authMiddleware, async (req, res) => {
   try {
     const engine = new TokenTalosEngine(config);
     await engine.init();
-    
+
     const result = await engine.execute({
       ...req.body,
       orgId: req.orgId,
@@ -188,14 +198,14 @@ router.post('/execute', authMiddleware, async (req, res) => {
 router.post('/prompt/construct', authMiddleware, async (req, res) => {
   const { provider, model, parts, endpoint, projectId } = req.body;
   const orgId = req.orgId;
-  
+
   const { processedParts, metadata } = await processPromptParts(parts, config);
 
   const finalProvider = provider || config.llmProvider || 'gemini';
   const finalModel = model || config.defaultModel || 'gemini-3-flash-preview';
 
   const prompt = new TokenTalosPrompt(finalProvider, finalModel);
-  
+
   for (const key in processedParts) {
     if (key === 'system') prompt.addSystem(processedParts[key], parts[key]);
     else if (key === 'context') prompt.addContext(processedParts[key], parts[key]);
@@ -206,7 +216,7 @@ router.post('/prompt/construct', authMiddleware, async (req, res) => {
 
   const messages = prompt.toMessages();
   const trackingData = prompt.getTrackingData();
-  
+
   const maxTokens = config.maxTokens || 32000;
   const thresholdAction = config.thresholdAction || 'warning';
 
@@ -248,10 +258,10 @@ router.post('/prompt/construct', authMiddleware, async (req, res) => {
         INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
         VALUES (?, ?, ?, ?, ?)
       `, [
-        trackingData.id, 
-        action.target, 
-        action.type, 
-        action.method || null, 
+        trackingData.id,
+        action.target,
+        action.type,
+        action.method || null,
         JSON.stringify(action)
       ]);
 
@@ -267,8 +277,8 @@ router.post('/prompt/construct', authMiddleware, async (req, res) => {
     }
 
     // 3. Heuristic Analysis
-    const analysis = runHeuristicAnalysis({ 
-      total_tokens: trackingData.total_tokens, 
+    const analysis = runHeuristicAnalysis({
+      total_tokens: trackingData.total_tokens,
       total_cost: inputCost,
       provider: finalProvider,
       model: finalModel
@@ -280,20 +290,21 @@ router.post('/prompt/construct', authMiddleware, async (req, res) => {
         INSERT INTO explain_plans (
           id, usage_id, variable_analysis, detected_issues, optimization_suggestions, 
           estimated_savings_pct, estimated_savings_usd,
-          mce_best_alternative_model, mce_best_alternative_provider, mce_best_alternative_cost, mce_savings_pct
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          mce_best_alternative_model, mce_best_alternative_provider, mce_best_alternative_cost, mce_savings_pct, mce_alternatives
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `, [
-        planId, 
-        trackingData.id, 
-        JSON.stringify(analysis.variable_analysis), 
-        JSON.stringify(analysis.detected_issues), 
+        planId,
+        trackingData.id,
+        JSON.stringify(analysis.variable_analysis),
+        JSON.stringify(analysis.detected_issues),
         JSON.stringify(analysis.optimization_suggestions),
-        analysis.estimated_savings_pct, 
+        analysis.estimated_savings_pct,
         analysis.estimated_savings_usd,
         analysis.mce_best_alternative_model || null,
         analysis.mce_best_alternative_provider || null,
         analysis.mce_best_alternative_cost || 0,
-        analysis.mce_savings_pct || 0
+        analysis.mce_savings_pct || 0,
+        analysis.mce_alternatives ? JSON.stringify(analysis.mce_alternatives) : null
       ]);
     }
 

package/lib/engine/ai_analyzer.js

@@ -9,7 +9,7 @@ export async function runAIAnalysis(config, usageRecord, variables) {
     const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });
 
     const variableInfo = variables.map(v => `${v.name} (${v.token_count} tokens): "${v.content.substring(0, 100)}..."`).join('\n');
-    
+
     const prompt = `
     Analyze this LLM prompt structure and suggest optimizations to reduce costs while maintaining performance.
     
@@ -31,29 +31,38 @@ export async function runAIAnalysis(config, usageRecord, variables) {
     const result = await model.generateContent(prompt);
     const response = await result.response;
     const text = response.text();
-    
+
     // Attempt to parse JSON from response
     try {
       const jsonStart = text.indexOf('{');
       const jsonEnd = text.lastIndexOf('}') + 1;
       const analysis = JSON.parse(text.substring(jsonStart, jsonEnd));
-      
+
       const calculator = getCostCalculator();
       const mceResult = calculator.getBestAlternative(
-        usageRecord.provider, 
-        usageRecord.model, 
-        usageRecord.input_tokens, 
+        usageRecord.provider,
+        usageRecord.model,
+        usageRecord.input_tokens,
         usageRecord.output_tokens,
         config.comparisonProviders
       );
-      
+      const allAlts = calculator.getAllAlternatives(
+        usageRecord.provider,
+        usageRecord.model,
+        usageRecord.input_tokens,
+        usageRecord.output_tokens,
+        config.comparisonProviders
+      );
+
+      analysis.mce_alternatives = allAlts;
+
       if (mceResult) {
         analysis.mce_best_alternative_model = mceResult.model;
         analysis.mce_best_alternative_provider = mceResult.provider;
         analysis.mce_best_alternative_cost = mceResult.cost;
         analysis.mce_savings_pct = ((usageRecord.total_cost - mceResult.cost) / usageRecord.total_cost) * 100;
       }
-      
+
       return analysis;
     } catch (err) {
       console.warn('AI analysis JSON parsing failed:', err);

package/lib/engine/analyzer.js

@@ -19,7 +19,8 @@ export function runHeuristicAnalysis(usageRecord, variables) {
   const outputTokens = usageRecord.output_tokens || Math.floor(totalTokens * 0.2);
 
   const bestAlt = calculator.getBestAlternative(provider, model, inputTokens, outputTokens);
-  
+  const allAlts = calculator.getAllAlternatives(provider, model, inputTokens, outputTokens);
+
   // Check if current model is deprecated
   const currentPricing = PRICING_DATA[provider.toLowerCase()]?.[model.toLowerCase()];
   if (currentPricing?.deprecated) {
@@ -27,18 +28,19 @@ export function runHeuristicAnalysis(usageRecord, variables) {
     suggestions.push(`Migrate to a current stable model (e.g., Gemini 2.0 Flash) to ensure service continuity.`);
   }
 
-  let mceResult = {};
+  let mceResult = {
+    mce_alternatives: allAlts
+  };
+
   if (bestAlt) {
     const currentCost = usageRecord.total_cost || 0;
     const savingsPct = currentCost > 0 ? ((currentCost - bestAlt.cost) / currentCost) * 100 : 0;
-    
+
     if (savingsPct > 10) { // Only suggest if savings are > 10%
-      mceResult = {
-        mce_best_alternative_model: bestAlt.model,
-        mce_best_alternative_provider: bestAlt.provider,
-        mce_best_alternative_cost: bestAlt.cost,
-        mce_savings_pct: savingsPct
-      };
+      mceResult.mce_best_alternative_model = bestAlt.model;
+      mceResult.mce_best_alternative_provider = bestAlt.provider;
+      mceResult.mce_best_alternative_cost = bestAlt.cost;
+      mceResult.mce_savings_pct = savingsPct;
       suggestions.push(`Potential Migration: Switching to ${bestAlt.provider}/${bestAlt.model} could reduce this prompt's cost by ${savingsPct.toFixed(0)}%.`);
     }
   }
@@ -46,7 +48,7 @@ export function runHeuristicAnalysis(usageRecord, variables) {
   for (const v of variables) {
     const rawPct = (v.token_count / totalTokens) * 100;
     const pct = Math.min(rawPct, 100); // Cap at 100% for display sanity
-    
+
     const vAnalysis = {
       variable_name: v.name,
       token_count: v.token_count,

package/lib/engine/db.js

@@ -54,7 +54,7 @@ export async function initDb(config) {
  */
 async function runMigrations(type, database, schemaName = '') {
   const prefix = (type === 'postgres' && schemaName) ? `${schemaName}.` : '';
-  
+
   if (type === 'sqlite') {
     // 1. Add org_id and project_id to usage_data if they don't exist
     const columns = await database.all(`PRAGMA table_info(usage_data)`);
@@ -78,6 +78,11 @@ async function runMigrations(type, database, schemaName = '') {
     const varColumns = await database.all(`PRAGMA table_info(prompt_variables)`);
     const hasOriginalContent = varColumns.some(c => c.name === 'original_content');
     if (!hasOriginalContent) await database.exec(`ALTER TABLE prompt_variables ADD COLUMN original_content TEXT`);
+
+    // Check explain_plans
+    const planColumns = await database.all(`PRAGMA table_info(explain_plans)`);
+    const hasMceAlternatives = planColumns.some(c => c.name === 'mce_alternatives');
+    if (!hasMceAlternatives) await database.exec(`ALTER TABLE explain_plans ADD COLUMN mce_alternatives TEXT`);
   } else {
     // Postgres migration check
     try {
@@ -132,6 +137,9 @@ async function runMigrations(type, database, schemaName = '') {
       if (!planCols.includes('variable_analysis')) {
         await database.query(`ALTER TABLE ${prefix}explain_plans ADD COLUMN variable_analysis TEXT`);
       }
+      if (!planCols.includes('mce_alternatives')) {
+        await database.query(`ALTER TABLE ${prefix}explain_plans ADD COLUMN mce_alternatives TEXT`);
+      }
     } catch (e) {
       console.warn('[TokenTalos] Migration check failed (Postgres):', e.message);
     }
@@ -265,7 +273,8 @@ function getSchema(type, schemaName = '') {
       mce_best_alternative_model TEXT,
       mce_best_alternative_provider TEXT,
       mce_best_alternative_cost REAL,
-      mce_savings_pct REAL
+      mce_savings_pct REAL,
+      mce_alternatives TEXT -- JSON representation of possible model alternatives
     );
 
     CREATE TABLE IF NOT EXISTS ${prefix}opv_results (

package/lib/engine/index.js

@@ -29,16 +29,16 @@ export class TokenTalosEngine {
 
   async init() {
     if (this.initialized) return;
-    
+
     // Default to SQLite if not specified
     const dbConfig = {
       databaseType: this.config.databaseType || 'sqlite',
-      sqlitePath: this.config.sqlitePath || ':memory:', 
+      sqlitePath: this.config.sqlitePath || ':memory:',
       ...this.config
     };
 
     this.db = await initDb(dbConfig);
-    
+
     // Create default org if it doesn't exist
     await this.ensureDefaultOrg();
 
@@ -52,10 +52,10 @@ export class TokenTalosEngine {
     try {
       // 1. Ensure Default Organization
       await db.run('INSERT INTO organizations (id, name) VALUES (?, ?) ON CONFLICT DO NOTHING', ['default_org', 'Default Organization']);
-      
+
       // 2. Ensure Default User (for local mode)
       await db.run('INSERT INTO users (id, email, name) VALUES (?, ?, ?) ON CONFLICT DO NOTHING', ['local_user', 'dev@tokentalos.local', 'Local Developer']);
-      
+
       // 3. Ensure Membership
       await db.run('INSERT INTO organization_members (org_id, user_id, role) VALUES (?, ?, ?) ON CONFLICT DO NOTHING', ['default_org', 'local_user', 'admin']);
     } catch (e) {
@@ -104,7 +104,7 @@ export class TokenTalosEngine {
     const finalModel = model || this.config.defaultModel || 'gemini-3-flash-preview';
 
     const prompt = this.createPrompt(finalProvider, finalModel);
-    
+
     // Add processed parts to the prompt
     for (const key in processedParts) {
       if (key === 'system') prompt.addSystem(processedParts[key], parts[key]);
@@ -131,7 +131,7 @@ export class TokenTalosEngine {
         // Log the cache hit as a usage event with 0 cost but record saved tokens
         const hitId = uuidv4();
         const db = this.getDb();
-        
+
         // Calculate what it WOULD have cost
         const [savedInputCost] = calculator.calculateCost(finalProvider, finalModel, prompt.getTrackingData().total_tokens, 0);
         const trackingData = prompt.getTrackingData();
@@ -140,7 +140,7 @@ export class TokenTalosEngine {
           INSERT INTO usage_data (id, org_id, project_id, type, provider, model, full_prompt, response_content, input_tokens, total_tokens, saved_tokens, saved_cost, input_cost, total_cost, endpoint, latency_ms, timestamp)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         `, [
-          hitId, finalOrgId, finalProjectId, 'cache_hit', finalProvider, finalModel, fullPromptString, cached.response_content, 0, 0, 
+          hitId, finalOrgId, finalProjectId, 'cache_hit', finalProvider, finalModel, fullPromptString, cached.response_content, 0, 0,
           prompt.getTrackingData().total_tokens, savedInputCost, 0, 0, endpoint, Date.now() - startTime, trackingData.timestamp
         ]);
 
@@ -156,10 +156,10 @@ export class TokenTalosEngine {
             INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
             VALUES (?, ?, ?, ?, ?)
           `, [
-            hitId, 
-            action.target, 
-            action.type, 
-            action.method || null, 
+            hitId,
+            action.target,
+            action.type,
+            action.method || null,
             JSON.stringify(action)
           ]);
         }
@@ -211,10 +211,10 @@ export class TokenTalosEngine {
         INSERT INTO variable_actions (usage_id, variable_name, action_type, action_method, details)
         VALUES (?, ?, ?, ?, ?)
       `, [
-        trackingData.id, 
-        action.target, 
-        action.type, 
-        action.method || null, 
+        trackingData.id,
+        action.target,
+        action.type,
+        action.method || null,
         JSON.stringify(action)
       ]);
     }
@@ -234,8 +234,8 @@ export class TokenTalosEngine {
     }
 
     // 5. Heuristic Analysis
-    const analysis = runHeuristicAnalysis({ 
-      total_tokens: result.input_tokens + result.output_tokens, 
+    const analysis = runHeuristicAnalysis({
+      total_tokens: result.input_tokens + result.output_tokens,
       input_tokens: result.input_tokens,
       output_tokens: result.output_tokens,
       total_cost: inputCost + outputCost,
@@ -248,20 +248,21 @@ export class TokenTalosEngine {
         INSERT INTO explain_plans (
           id, usage_id, variable_analysis, detected_issues, optimization_suggestions, 
           estimated_savings_pct, estimated_savings_usd,
-          mce_best_alternative_model, mce_best_alternative_provider, mce_best_alternative_cost, mce_savings_pct
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          mce_best_alternative_model, mce_best_alternative_provider, mce_best_alternative_cost, mce_savings_pct, mce_alternatives
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `, [
-        planId, 
-        trackingData.id, 
-        JSON.stringify(analysis.variable_analysis), 
-        JSON.stringify(analysis.detected_issues), 
+        planId,
+        trackingData.id,
+        JSON.stringify(analysis.variable_analysis),
+        JSON.stringify(analysis.detected_issues),
         JSON.stringify(analysis.optimization_suggestions),
-        analysis.estimated_savings_pct, 
+        analysis.estimated_savings_pct,
         analysis.estimated_savings_usd,
         analysis.mce_best_alternative_model || null,
         analysis.mce_best_alternative_provider || null,
         analysis.mce_best_alternative_cost || 0,
-        analysis.mce_savings_pct || 0
+        analysis.mce_savings_pct || 0,
+        analysis.mce_alternatives ? JSON.stringify(analysis.mce_alternatives) : null
       ]);
     }
 

package/lib/engine/pricing.js

@@ -50,9 +50,26 @@ export const PRICING_DATA = {
   }
 };
 
+// Map common provider aliases to their canonical PRICING_DATA keys
+const PROVIDER_ALIASES = {
+  'gemini': 'google',
+  'gcp': 'google',
+  'openai-api': 'openai',
+  'claude': 'anthropic',
+  'aws': 'amazon',
+  'bedrock': 'amazon',
+};
+
+function normalizeProvider(provider) {
+  if (!provider) return provider;
+  const lower = provider.toLowerCase();
+  return PROVIDER_ALIASES[lower] || lower;
+}
+
 export class CostCalculator {
   calculateCost(provider, model, inputTokens, outputTokens) {
-    const providerPricing = PRICING_DATA[provider.toLowerCase()];
+    const normalizedProvider = normalizeProvider(provider);
+    const providerPricing = PRICING_DATA[normalizedProvider];
     if (!providerPricing) return [0, 0];
 
     const modelPricing = providerPricing[model.toLowerCase()];
@@ -66,10 +83,16 @@ export class CostCalculator {
   }
 
   getBestAlternative(provider, model, inputTokens, outputTokens, preferredProviders = []) {
-    let bestAlt = null;
-    let currentCost = this.calculateCost(provider, model, inputTokens, outputTokens).reduce((a, b) => a + b, 0);
+    const alternatives = this.getAllAlternatives(provider, model, inputTokens, outputTokens, preferredProviders);
+    if (alternatives.length === 0) return null;
+    return alternatives[0];
+  }
+
+  getAllAlternatives(provider, model, inputTokens, outputTokens, preferredProviders = []) {
+    const normalizedProvider = normalizeProvider(provider);
+    let alternatives = [];
+    let currentCost = this.calculateCost(normalizedProvider, model, inputTokens, outputTokens).reduce((a, b) => a + b, 0);
 
-    // If no preference, use all available in PRICING_DATA
     const targets = preferredProviders.length > 0 ? preferredProviders : Object.keys(PRICING_DATA);
 
     for (const targetProvider of targets) {
@@ -78,22 +101,23 @@ export class CostCalculator {
 
       for (const targetModel in models) {
         const pricing = models[targetModel];
-        // Skip current model or deprecated targets
-        if ((targetProvider === provider.toLowerCase() && targetModel === model.toLowerCase()) || pricing.deprecated) continue;
+        // Skip the current model (compare against normalized provider)
+        if ((targetProvider === normalizedProvider && targetModel === model.toLowerCase()) || pricing.deprecated) continue;
 
         const [altInput, altOutput] = this.calculateCost(targetProvider, targetModel, inputTokens, outputTokens);
         const altTotal = altInput + altOutput;
 
-        if (altTotal < currentCost && (!bestAlt || altTotal < bestAlt.cost)) {
-          bestAlt = {
-            model: targetModel,
-            provider: targetProvider,
-            cost: altTotal
-          };
-        }
+        alternatives.push({
+          model: targetModel,
+          provider: targetProvider,
+          cost: altTotal,
+          savingsPct: currentCost > 0 ? ((currentCost - altTotal) / currentCost) * 100 : 0
+        });
       }
     }
-    return bestAlt;
+
+    // Sort by cost ascending
+    return alternatives.sort((a, b) => a.cost - b.cost);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meller/tokentalos",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Token Talos: The ORM for LLMs. A standalone gateway and library for cost-optimized, secure, and tracked prompt orchestration.",
   "type": "module",
   "publishConfig": {
@@ -57,8 +57,10 @@
     "js-tiktoken": "^1.0.7",
     "openai": "^6.22.0",
     "pg": "^8.18.0",
-    "sqlite": "^5.0.1",
-    "sqlite3": "^5.1.6",
     "uuid": "^9.0.1"
+  },
+  "optionalDependencies": {
+    "sqlite": "^5.0.1",
+    "sqlite3": "^5.1.6"
   }
-}
+}