@retab/node 0.0.0-reserved → 0.0.43

package/dist/utils/benchmarking.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Benchmarking and evaluation utilities for model comparison
+ * Equivalent to Python's benchmarking.py
+ */
+export interface EvaluationMetrics {
+    accuracy: number;
+    precision: number;
+    recall: number;
+    f1Score: number;
+    exactMatch: number;
+    levenshteinDistance: number;
+    jaccardSimilarity: number;
+    hammingDistance: number;
+    fieldAccuracy: Record<string, number>;
+    completeness: number;
+    errorRate: number;
+}
+export interface SingleFileEvalResult {
+    filename: string;
+    metrics: EvaluationMetrics;
+    predictions: any[];
+    groundTruths: any[];
+    differences: Record<string, any>[];
+    executionTime: number;
+}
+export interface BenchmarkResult {
+    model: string;
+    overallMetrics: EvaluationMetrics;
+    fileResults: SingleFileEvalResult[];
+    aggregateStats: {
+        meanAccuracy: number;
+        stdDevAccuracy: number;
+        meanF1: number;
+        stdDevF1: number;
+        totalFiles: number;
+        totalPredictions: number;
+    };
+    executionTime: number;
+}
+export interface DictionaryDifference {
+    field: string;
+    predicted: any;
+    groundTruth: any;
+    differenceType: 'missing' | 'extra' | 'value_mismatch' | 'type_mismatch';
+    path: string;
+}
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+/**
+ * Calculate Jaccard similarity between two sets
+ */
+export declare function jaccardSimilarity(set1: Set<any>, set2: Set<any>): number;
+/**
+ * Calculate Hamming distance between two strings
+ */
+export declare function hammingDistance(str1: string, str2: string): number;
+/**
+ * Flatten nested object into dot-notation keys
+ */
+export declare function flattenObject(obj: any, prefix?: string): Record<string, any>;
+/**
+ * Compute detailed differences between two dictionaries
+ */
+export declare function computeDictDifference(predicted: any, groundTruth: any, path?: string): DictionaryDifference[];
+/**
+ * Aggregate dictionary differences across multiple examples
+ */
+export declare function aggregateDictDifferences(differences: DictionaryDifference[][]): Record<string, {
+    count: number;
+    percentage: number;
+    examples: DictionaryDifference[];
+}>;
+/**
+ * Calculate comprehensive evaluation metrics
+ */
+export declare function calculateMetrics(predictions: any[], groundTruths: any[]): EvaluationMetrics;
+/**
+ * Single file evaluation class
+ */
+export declare class SingleFileEval {
+    private filename;
+    private predictions;
+    private groundTruths;
+    constructor(filename: string, predictions: any[], groundTruths: any[]);
+    evaluate(): Promise<SingleFileEvalResult>;
+}
+/**
+ * Plot metrics with uncertainty (text-based visualization)
+ */
+export declare function plotMetricsWithUncertainty(results: BenchmarkResult[]): void;
+/**
+ * Benchmark multiple models
+ */
+export declare function benchmark(models: string[], testDataPath: string, groundTruthPath: string, evaluationFunction: (model: string, testData: any[]) => Promise<any[]>): Promise<BenchmarkResult[]>;
+/**
+ * Save benchmark results to file
+ */
+export declare function saveBenchmarkResults(results: BenchmarkResult[], outputPath: string): Promise<void>;
+declare const _default: {
+    SingleFileEval: typeof SingleFileEval;
+    calculateMetrics: typeof calculateMetrics;
+    computeDictDifference: typeof computeDictDifference;
+    aggregateDictDifferences: typeof aggregateDictDifferences;
+    levenshteinDistance: typeof levenshteinDistance;
+    jaccardSimilarity: typeof jaccardSimilarity;
+    hammingDistance: typeof hammingDistance;
+    flattenObject: typeof flattenObject;
+    plotMetricsWithUncertainty: typeof plotMetricsWithUncertainty;
+    benchmark: typeof benchmark;
+    saveBenchmarkResults: typeof saveBenchmarkResults;
+};
+export default _default;
+//# sourceMappingURL=benchmarking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarking.d.ts","sourceRoot":"","sources":["../../src/utils/benchmarking.ts"],"names":[],"mappings":"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"}

package/dist/utils/benchmarking.js

@@ -0,0 +1,355 @@
+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

@@ -0,0 +1,70 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,79 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1 @@
+{"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"}