@retab/node 0.0.48 → 0.0.52

package/dist/utils/benchmarking.js

@@ -1,355 +0,0 @@
-import { readJSONL, writeJSONL } from './jsonl.js';
-/**
- * Calculate Levenshtein distance between two strings
- */
-export function levenshteinDistance(str1, str2) {
-    const matrix = [];
-    // Initialize matrix
-    for (let i = 0; i <= str2.length; i++) {
-        matrix[i] = [i];
-    }
-    for (let j = 0; j <= str1.length; j++) {
-        matrix[0][j] = j;
-    }
-    // Fill matrix
-    for (let i = 1; i <= str2.length; i++) {
-        for (let j = 1; j <= str1.length; j++) {
-            if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
-                matrix[i][j] = matrix[i - 1][j - 1];
-            }
-            else {
-                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // substitution
-                matrix[i][j - 1] + 1, // insertion
-                matrix[i - 1][j] + 1 // deletion
-                );
-            }
-        }
-    }
-    return matrix[str2.length][str1.length];
-}
-/**
- * Calculate Jaccard similarity between two sets
- */
-export function jaccardSimilarity(set1, set2) {
-    const intersection = new Set([...set1].filter(x => set2.has(x)));
-    const union = new Set([...set1, ...set2]);
-    if (union.size === 0)
-        return 1.0;
-    return intersection.size / union.size;
-}
-/**
- * Calculate Hamming distance between two strings
- */
-export function hammingDistance(str1, str2) {
-    if (str1.length !== str2.length) {
-        throw new Error('Strings must be of equal length for Hamming distance');
-    }
-    let distance = 0;
-    for (let i = 0; i < str1.length; i++) {
-        if (str1[i] !== str2[i]) {
-            distance++;
-        }
-    }
-    return distance;
-}
-/**
- * Flatten nested object into dot-notation keys
- */
-export function flattenObject(obj, prefix = '') {
-    const flattened = {};
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            const newKey = prefix ? `${prefix}.${key}` : key;
-            const value = obj[key];
-            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-                Object.assign(flattened, flattenObject(value, newKey));
-            }
-            else {
-                flattened[newKey] = value;
-            }
-        }
-    }
-    return flattened;
-}
-/**
- * Compute detailed differences between two dictionaries
- */
-export function computeDictDifference(predicted, groundTruth, path = '') {
-    const differences = [];
-    const flatPredicted = flattenObject(predicted);
-    const flatGroundTruth = flattenObject(groundTruth);
-    const allKeys = new Set([
-        ...Object.keys(flatPredicted),
-        ...Object.keys(flatGroundTruth)
-    ]);
-    for (const key of allKeys) {
-        const fullPath = path ? `${path}.${key}` : key;
-        const predValue = flatPredicted[key];
-        const truthValue = flatGroundTruth[key];
-        if (!(key in flatPredicted)) {
-            differences.push({
-                field: key,
-                predicted: undefined,
-                groundTruth: truthValue,
-                differenceType: 'missing',
-                path: fullPath,
-            });
-        }
-        else if (!(key in flatGroundTruth)) {
-            differences.push({
-                field: key,
-                predicted: predValue,
-                groundTruth: undefined,
-                differenceType: 'extra',
-                path: fullPath,
-            });
-        }
-        else if (predValue !== truthValue) {
-            const diffType = typeof predValue !== typeof truthValue ? 'type_mismatch' : 'value_mismatch';
-            differences.push({
-                field: key,
-                predicted: predValue,
-                groundTruth: truthValue,
-                differenceType: diffType,
-                path: fullPath,
-            });
-        }
-    }
-    return differences;
-}
-/**
- * Aggregate dictionary differences across multiple examples
- */
-export function aggregateDictDifferences(differences) {
-    const aggregated = {};
-    // Group differences by field path
-    for (const diffList of differences) {
-        for (const diff of diffList) {
-            if (!aggregated[diff.path]) {
-                aggregated[diff.path] = [];
-            }
-            aggregated[diff.path].push(diff);
-        }
-    }
-    const totalExamples = differences.length;
-    const result = {};
-    for (const [path, diffs] of Object.entries(aggregated)) {
-        result[path] = {
-            count: diffs.length,
-            percentage: (diffs.length / totalExamples) * 100,
-            examples: diffs.slice(0, 5), // Keep first 5 examples
-        };
-    }
-    return result;
-}
-/**
- * Calculate comprehensive evaluation metrics
- */
-export function calculateMetrics(predictions, groundTruths) {
-    if (predictions.length !== groundTruths.length) {
-        throw new Error('Predictions and ground truths must have the same length');
-    }
-    const n = predictions.length;
-    let exactMatches = 0;
-    let totalLevenshtein = 0;
-    let totalJaccard = 0;
-    let totalHamming = 0;
-    let validHamming = 0;
-    const fieldAccuracy = {};
-    const differences = [];
-    for (let i = 0; i < n; i++) {
-        const pred = predictions[i];
-        const truth = groundTruths[i];
-        // Exact match
-        if (JSON.stringify(pred) === JSON.stringify(truth)) {
-            exactMatches++;
-        }
-        // String representations for text-based metrics
-        const predStr = JSON.stringify(pred);
-        const truthStr = JSON.stringify(truth);
-        // Levenshtein distance
-        totalLevenshtein += levenshteinDistance(predStr, truthStr);
-        // Jaccard similarity (using character sets)
-        const predSet = new Set(predStr.split(''));
-        const truthSet = new Set(truthStr.split(''));
-        totalJaccard += jaccardSimilarity(predSet, truthSet);
-        // Hamming distance (only for same-length strings)
-        if (predStr.length === truthStr.length) {
-            totalHamming += hammingDistance(predStr, truthStr);
-            validHamming++;
-        }
-        // Field-level accuracy
-        const diff = computeDictDifference(pred, truth);
-        differences.push(diff);
-        const flatPred = flattenObject(pred);
-        const flatTruth = flattenObject(truth);
-        for (const key of Object.keys(flatTruth)) {
-            if (!fieldAccuracy[key]) {
-                fieldAccuracy[key] = { correct: 0, total: 0 };
-            }
-            fieldAccuracy[key].total++;
-            if (flatPred[key] === flatTruth[key]) {
-                fieldAccuracy[key].correct++;
-            }
-        }
-    }
-    // Calculate field accuracy percentages
-    const fieldAccuracyPercentages = {};
-    for (const [field, stats] of Object.entries(fieldAccuracy)) {
-        fieldAccuracyPercentages[field] = (stats.correct / stats.total) * 100;
-    }
-    // Calculate aggregate differences
-    const aggregatedDiffs = aggregateDictDifferences(differences);
-    const completeness = 100 - (Object.keys(aggregatedDiffs).length / Object.keys(fieldAccuracy).length) * 100;
-    return {
-        accuracy: (exactMatches / n) * 100,
-        precision: (exactMatches / n) * 100, // Simplified for exact match scenario
-        recall: (exactMatches / n) * 100, // Simplified for exact match scenario
-        f1Score: (exactMatches / n) * 100, // Simplified for exact match scenario
-        exactMatch: (exactMatches / n) * 100,
-        levenshteinDistance: totalLevenshtein / n,
-        jaccardSimilarity: (totalJaccard / n) * 100,
-        hammingDistance: validHamming > 0 ? totalHamming / validHamming : 0,
-        fieldAccuracy: fieldAccuracyPercentages,
-        completeness: Math.max(0, completeness),
-        errorRate: ((n - exactMatches) / n) * 100,
-    };
-}
-/**
- * Single file evaluation class
- */
-export class SingleFileEval {
-    constructor(filename, predictions, groundTruths) {
-        this.filename = filename;
-        this.predictions = predictions;
-        this.groundTruths = groundTruths;
-    }
-    async evaluate() {
-        const startTime = Date.now();
-        const metrics = calculateMetrics(this.predictions, this.groundTruths);
-        const differences = [];
-        for (let i = 0; i < this.predictions.length; i++) {
-            const diff = computeDictDifference(this.predictions[i], this.groundTruths[i]);
-            if (diff.length > 0) {
-                differences.push({
-                    index: i,
-                    differences: diff,
-                });
-            }
-        }
-        const executionTime = Date.now() - startTime;
-        return {
-            filename: this.filename,
-            metrics,
-            predictions: this.predictions,
-            groundTruths: this.groundTruths,
-            differences,
-            executionTime,
-        };
-    }
-}
-/**
- * Plot metrics with uncertainty (text-based visualization)
- */
-export function plotMetricsWithUncertainty(results) {
-    console.log('\n📊 Model Performance Comparison');
-    console.log('═'.repeat(60));
-    const maxModelNameLength = Math.max(...results.map(r => r.model.length));
-    console.log(`\n${'Model'.padEnd(maxModelNameLength)} | Accuracy | F1 Score | Exec Time`);
-    console.log('─'.repeat(maxModelNameLength + 35));
-    for (const result of results) {
-        const accuracy = result.overallMetrics.accuracy.toFixed(1);
-        const f1 = result.overallMetrics.f1Score.toFixed(1);
-        const execTime = `${(result.executionTime / 1000).toFixed(1)}s`;
-        console.log(`${result.model.padEnd(maxModelNameLength)} | ${accuracy.padStart(6)}% | ${f1.padStart(6)}% | ${execTime.padStart(8)}`);
-    }
-    // Show best performing model
-    const bestModel = results.reduce((best, current) => current.overallMetrics.accuracy > best.overallMetrics.accuracy ? current : best);
-    console.log(`\n🏆 Best performing model: ${bestModel.model} (${bestModel.overallMetrics.accuracy.toFixed(1)}% accuracy)`);
-    console.log('═'.repeat(60));
-}
-/**
- * Benchmark multiple models
- */
-export async function benchmark(models, testDataPath, groundTruthPath, evaluationFunction) {
-    console.log(`🚀 Starting benchmark of ${models.length} models...`);
-    // Load test data and ground truth
-    const testData = await readJSONL(testDataPath);
-    const groundTruth = await readJSONL(groundTruthPath);
-    if (testData.length !== groundTruth.length) {
-        throw new Error('Test data and ground truth must have the same length');
-    }
-    const results = [];
-    for (let i = 0; i < models.length; i++) {
-        const model = models[i];
-        console.log(`\n📊 Evaluating model: ${model} (${i + 1}/${models.length})`);
-        const startTime = Date.now();
-        try {
-            // Get predictions from model
-            const predictions = await evaluationFunction(model, testData);
-            if (predictions.length !== groundTruth.length) {
-                throw new Error(`Model ${model} returned ${predictions.length} predictions, expected ${groundTruth.length}`);
-            }
-            // Calculate metrics
-            const metrics = calculateMetrics(predictions, groundTruth);
-            // Create single file evaluation
-            const fileEval = new SingleFileEval(testDataPath, predictions, groundTruth);
-            const fileResult = await fileEval.evaluate();
-            const executionTime = Date.now() - startTime;
-            results.push({
-                model,
-                overallMetrics: metrics,
-                fileResults: [fileResult],
-                aggregateStats: {
-                    meanAccuracy: metrics.accuracy,
-                    stdDevAccuracy: 0, // Would need multiple runs to calculate
-                    meanF1: metrics.f1Score,
-                    stdDevF1: 0,
-                    totalFiles: 1,
-                    totalPredictions: predictions.length,
-                },
-                executionTime,
-            });
-            console.log(`   ✅ Accuracy: ${metrics.accuracy.toFixed(1)}%`);
-            console.log(`   ⏱️  Time: ${(executionTime / 1000).toFixed(1)}s`);
-        }
-        catch (error) {
-            console.error(`   ❌ Failed to evaluate ${model}:`, error);
-        }
-    }
-    // Display final comparison
-    plotMetricsWithUncertainty(results);
-    return results;
-}
-/**
- * Save benchmark results to file
- */
-export async function saveBenchmarkResults(results, outputPath) {
-    const summary = {
-        timestamp: new Date().toISOString(),
-        totalModels: results.length,
-        results: results.map(r => ({
-            model: r.model,
-            accuracy: r.overallMetrics.accuracy,
-            f1Score: r.overallMetrics.f1Score,
-            executionTime: r.executionTime,
-            totalPredictions: r.aggregateStats.totalPredictions,
-        })),
-        detailed: results,
-    };
-    await writeJSONL(outputPath, [summary]);
-    console.log(`📄 Benchmark results saved to ${outputPath}`);
-}
-export default {
-    SingleFileEval,
-    calculateMetrics,
-    computeDictDifference,
-    aggregateDictDifferences,
-    levenshteinDistance,
-    jaccardSimilarity,
-    hammingDistance,
-    flattenObject,
-    plotMetricsWithUncertainty,
-    benchmark,
-    saveBenchmarkResults,
-};

package/dist/utils/chat.d.ts

@@ -1,70 +0,0 @@
-/**
- * Chat message processing utilities
- * Equivalent to Python's utils/chat.py
- */
-export interface ChatMessage {
-    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
-    content: string | null;
-    name?: string;
-    function_call?: {
-        name: string;
-        arguments: string;
-    };
-    tool_calls?: Array<{
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
-    tool_call_id?: string;
-}
-export interface ChatCompletionRequest {
-    model: string;
-    messages: ChatMessage[];
-    temperature?: number;
-    max_tokens?: number;
-    top_p?: number;
-    frequency_penalty?: number;
-    presence_penalty?: number;
-    stop?: string | string[];
-    stream?: boolean;
-    functions?: Array<{
-        name: string;
-        description?: string;
-        parameters: Record<string, any>;
-    }>;
-    function_call?: 'auto' | 'none' | {
-        name: string;
-    };
-    tools?: Array<{
-        type: 'function';
-        function: {
-            name: string;
-            description?: string;
-            parameters: Record<string, any>;
-        };
-    }>;
-    tool_choice?: 'auto' | 'none' | {
-        type: 'function';
-        function: {
-            name: string;
-        };
-    };
-}
-export declare function formatMessagesForProvider(messages: ChatMessage[], provider: 'openai' | 'anthropic' | 'xai' | 'gemini'): any[];
-export declare function extractSystemPrompt(messages: ChatMessage[]): {
-    system: string | null;
-    filtered: ChatMessage[];
-};
-export declare function validateMessages(messages: ChatMessage[]): string[];
-export declare function countTokensInMessages(messages: ChatMessage[], _model?: string): number;
-declare const _default: {
-    formatMessagesForProvider: typeof formatMessagesForProvider;
-    extractSystemPrompt: typeof extractSystemPrompt;
-    validateMessages: typeof validateMessages;
-    countTokensInMessages: typeof countTokensInMessages;
-};
-export default _default;
-//# sourceMappingURL=chat.d.ts.map

package/dist/utils/chat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../src/utils/chat.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;IAC5D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE;QACd,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,UAAU,CAAC,EAAE,KAAK,CAAC;QACjB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC;YACb,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC;KACH,CAAC,CAAC;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,KAAK,CAAC;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACjC,CAAC,CAAC;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,KAAK,CAAC,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC;YACb,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SACjC,CAAC;KACH,CAAC,CAAC;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG;QAAE,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;CAClF;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,WAAW,EAAE,EACvB,QAAQ,EAAE,QAAQ,GAAG,WAAW,GAAG,KAAK,GAAG,QAAQ,GAClD,GAAG,EAAE,CAqBP;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,EAAE,WAAW,EAAE,CAAA;CAAE,CAW/G;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,EAAE,CAyBlE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,MAAM,GAAE,MAAsB,GAAG,MAAM,CAwBrG;;;;;;;AAED,wBAKE"}

package/dist/utils/chat.js

@@ -1,79 +0,0 @@
-/**
- * Chat message processing utilities
- * Equivalent to Python's utils/chat.py
- */
-export function formatMessagesForProvider(messages, provider) {
-    switch (provider) {
-        case 'openai':
-        case 'xai':
-            return messages;
-        case 'anthropic':
-            return messages.map(msg => ({
-                role: msg.role === 'system' ? 'user' : msg.role,
-                content: msg.content,
-            }));
-        case 'gemini':
-            return messages.map(msg => ({
-                role: msg.role === 'assistant' ? 'model' : 'user',
-                parts: [{ text: msg.content }],
-            }));
-        default:
-            return messages;
-    }
-}
-export function extractSystemPrompt(messages) {
-    const systemMessages = messages.filter(msg => msg.role === 'system');
-    const nonSystemMessages = messages.filter(msg => msg.role !== 'system');
-    const systemPrompt = systemMessages.length > 0 ?
-        systemMessages.map(msg => msg.content).join('\n') : null;
-    return {
-        system: systemPrompt,
-        filtered: nonSystemMessages,
-    };
-}
-export function validateMessages(messages) {
-    const errors = [];
-    if (!Array.isArray(messages) || messages.length === 0) {
-        errors.push('Messages array is required and cannot be empty');
-        return errors;
-    }
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        if (!msg.role) {
-            errors.push(`Message at index ${i} is missing role`);
-        }
-        if (!['system', 'user', 'assistant', 'function', 'tool'].includes(msg.role)) {
-            errors.push(`Message at index ${i} has invalid role: ${msg.role}`);
-        }
-        if (msg.content === null && !msg.function_call && !msg.tool_calls) {
-            errors.push(`Message at index ${i} must have content, function_call, or tool_calls`);
-        }
-    }
-    return errors;
-}
-export function countTokensInMessages(messages, _model = 'gpt-4o-mini') {
-    // Simplified token counting - in production use tiktoken
-    let totalTokens = 0;
-    for (const message of messages) {
-        // Role tokens
-        totalTokens += 4; // Base tokens per message
-        // Content tokens
-        if (message.content) {
-            totalTokens += Math.ceil(message.content.length / 4); // ~4 chars per token
-        }
-        // Function/tool call tokens
-        if (message.function_call) {
-            totalTokens += Math.ceil(JSON.stringify(message.function_call).length / 4);
-        }
-        if (message.tool_calls) {
-            totalTokens += Math.ceil(JSON.stringify(message.tool_calls).length / 4);
-        }
-    }
-    return totalTokens;
-}
-export default {
-    formatMessagesForProvider,
-    extractSystemPrompt,
-    validateMessages,
-    countTokensInMessages,
-};

package/dist/utils/cost_calculation.d.ts

@@ -1,26 +0,0 @@
-import { Amount } from '../types/ai_models.js';
-interface Usage {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    total_tokens?: number;
-    cached_tokens?: number;
-}
-/**
- * Compute the cost of a model usage.
- */
-export declare function computeCostFromModel(model: string, usage: Usage, currency?: string): Amount;
-/**
- * Compute cost breakdown for detailed analysis.
- */
-export interface CostBreakdown {
-    prompt_cost: Amount;
-    completion_cost: Amount;
-    cached_cost: Amount;
-    total_cost: Amount;
-    prompt_tokens: number;
-    completion_tokens: number;
-    cached_tokens: number;
-}
-export declare function computeCostFromModelWithBreakdown(model: string, usage: Usage, currency?: string): CostBreakdown;
-export {};
-//# sourceMappingURL=cost_calculation.d.ts.map

package/dist/utils/cost_calculation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cost_calculation.d.ts","sourceRoot":"","sources":["../../src/utils/cost_calculation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAW,MAAM,uBAAuB,CAAC;AA0CxD,UAAU,KAAK;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,EACZ,QAAQ,GAAE,MAAc,GACvB,MAAM,CAwBR;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,KAAK,EACZ,QAAQ,GAAE,MAAc,GACvB,aAAa,CAwCf"}

package/dist/utils/cost_calculation.js

@@ -1,99 +0,0 @@
-// Basic pricing data for common models (this would typically come from a config or API)
-const MODEL_PRICING = {
-    'gpt-4o': {
-        text: { prompt: 2.5, completion: 10.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gpt-4o-mini': {
-        text: { prompt: 0.15, completion: 0.6, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gpt-4o-2024-11-20': {
-        text: { prompt: 2.5, completion: 10.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gpt-4o-2024-08-06': {
-        text: { prompt: 2.5, completion: 10.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gpt-4o-mini-2024-07-18': {
-        text: { prompt: 0.15, completion: 0.6, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'claude-3-5-sonnet-latest': {
-        text: { prompt: 3.0, completion: 15.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'claude-3-5-sonnet-20241022': {
-        text: { prompt: 3.0, completion: 15.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gemini-2.0-flash': {
-        text: { prompt: 0.075, completion: 0.3, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-    'gemini-2.5-pro': {
-        text: { prompt: 1.25, completion: 5.0, cached_discount: 1.0 },
-        ft_price_hike: 1.0,
-    },
-};
-/**
- * Compute the cost of a model usage.
- */
-export function computeCostFromModel(model, usage, currency = 'USD') {
-    const pricing = MODEL_PRICING[model];
-    if (!pricing) {
-        // Return zero cost for unknown models
-        return { value: 0, currency };
-    }
-    const promptTokens = usage.prompt_tokens || 0;
-    const completionTokens = usage.completion_tokens || 0;
-    const cachedTokens = usage.cached_tokens || 0;
-    // Calculate costs per 1M tokens
-    const promptCost = (promptTokens / 1000000) * pricing.text.prompt;
-    const completionCost = (completionTokens / 1000000) * pricing.text.completion;
-    // Apply cached discount if applicable
-    const cachedCost = (cachedTokens / 1000000) * pricing.text.prompt * pricing.text.cached_discount;
-    const totalCost = promptCost + completionCost + cachedCost;
-    return {
-        value: Math.round(totalCost * 100000) / 100000, // Round to 5 decimal places
-        currency,
-    };
-}
-export function computeCostFromModelWithBreakdown(model, usage, currency = 'USD') {
-    const pricing = MODEL_PRICING[model];
-    if (!pricing) {
-        const zeroCost = { value: 0, currency };
-        return {
-            prompt_cost: zeroCost,
-            completion_cost: zeroCost,
-            cached_cost: zeroCost,
-            total_cost: zeroCost,
-            prompt_tokens: usage.prompt_tokens || 0,
-            completion_tokens: usage.completion_tokens || 0,
-            cached_tokens: usage.cached_tokens || 0,
-        };
-    }
-    const promptTokens = usage.prompt_tokens || 0;
-    const completionTokens = usage.completion_tokens || 0;
-    const cachedTokens = usage.cached_tokens || 0;
-    const promptCostValue = (promptTokens / 1000000) * pricing.text.prompt;
-    const completionCostValue = (completionTokens / 1000000) * pricing.text.completion;
-    const cachedCostValue = (cachedTokens / 1000000) * pricing.text.prompt * pricing.text.cached_discount;
-    const promptCost = { value: Math.round(promptCostValue * 100000) / 100000, currency };
-    const completionCost = { value: Math.round(completionCostValue * 100000) / 100000, currency };
-    const cachedCost = { value: Math.round(cachedCostValue * 100000) / 100000, currency };
-    const totalCost = {
-        value: Math.round((promptCostValue + completionCostValue + cachedCostValue) * 100000) / 100000,
-        currency
-    };
-    return {
-        prompt_cost: promptCost,
-        completion_cost: completionCost,
-        cached_cost: cachedCost,
-        total_cost: totalCost,
-        prompt_tokens: promptTokens,
-        completion_tokens: completionTokens,
-        cached_tokens: cachedTokens,
-    };
-}