@retab/node 0.0.48 → 0.0.52

package/dist/utils/model_cards.js

@@ -1,462 +0,0 @@
-/**
- * Model cards and AI provider configuration management
- * Equivalent to Python's utils/_model_cards/ directory
- */
-// Built-in model cards
-export const modelCards = {
-    'gpt-4o': {
-        id: 'gpt-4o',
-        name: 'GPT-4o',
-        provider: 'openai',
-        model_family: 'gpt-4',
-        version: '2024-08-06',
-        description: 'Most advanced multimodal model with vision capabilities',
-        capabilities: {
-            text_generation: true,
-            text_analysis: true,
-            document_extraction: true,
-            image_understanding: true,
-            function_calling: true,
-            json_mode: true,
-            streaming: true,
-            batch_processing: true,
-            fine_tuning: false,
-            embedding_generation: false,
-            reasoning: true,
-            code_generation: true,
-            multilingual: true,
-            supported_languages: ['en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh'],
-            max_context_window: 128000,
-            max_output_tokens: 16384,
-        },
-        limitations: {
-            rate_limits: {
-                requests_per_minute: 10000,
-                tokens_per_minute: 2000000,
-            },
-            content_restrictions: ['NSFW content', 'Illegal activities', 'Personal data'],
-            knowledge_cutoff_date: new Date('2024-04-01'),
-        },
-        pricing: {
-            input_tokens_per_1k: 0.0025,
-            output_tokens_per_1k: 0.01,
-            image_tokens_per_1k: 0.001275,
-            currency: 'USD',
-            billing_unit: 'token',
-        },
-        performance_benchmarks: {
-            accuracy_scores: {
-                general_text: 0.95,
-                document_extraction: 0.92,
-                reasoning: 0.94,
-                code_generation: 0.91,
-                multilingual: 0.89,
-            },
-            speed_metrics: {
-                average_latency_ms: 1200,
-                tokens_per_second: 45,
-                throughput_requests_per_minute: 8500,
-            },
-            reliability_metrics: {
-                uptime_percentage: 99.9,
-                error_rate_percentage: 0.1,
-                consistency_score: 0.93,
-            },
-            cost_efficiency: {
-                cost_per_accurate_response: 0.015,
-                cost_performance_ratio: 6.3,
-            },
-        },
-        technical_specs: {
-            architecture: 'Transformer',
-            inference_hardware: ['GPU'],
-            optimization_techniques: ['Mixed precision', 'Model parallelism'],
-            supported_formats: {
-                input: ['text', 'image'],
-                output: ['text', 'json'],
-            },
-            api_compatibility: {
-                openai_compatible: true,
-                custom_endpoints: false,
-                webhook_support: false,
-            },
-        },
-        usage_guidelines: {
-            recommended_use_cases: [
-                'Complex document extraction',
-                'Multimodal analysis',
-                'Advanced reasoning tasks',
-                'Code generation',
-            ],
-            not_recommended_for: [
-                'Simple text classification',
-                'High-frequency API calls',
-                'Cost-sensitive applications',
-            ],
-            best_practices: [
-                'Use clear, specific prompts',
-                'Leverage function calling for structured output',
-                'Optimize context window usage',
-            ],
-            prompt_engineering_tips: [
-                'Be explicit about output format',
-                'Provide examples for complex tasks',
-                'Use system messages for role definition',
-            ],
-            parameter_recommendations: {
-                temperature: {
-                    creative_tasks: 0.7,
-                    analytical_tasks: 0.1,
-                    extraction_tasks: 0.0,
-                },
-            },
-            context_window_optimization: [
-                'Place important information early',
-                'Use concise prompts',
-                'Chunk large documents',
-            ],
-        },
-        supported_features: [
-            'vision',
-            'function_calling',
-            'json_mode',
-            'streaming',
-            'batch',
-        ],
-        deprecated: false,
-        created_at: new Date('2024-05-13'),
-        updated_at: new Date('2024-08-06'),
-    },
-    'gpt-4o-mini': {
-        id: 'gpt-4o-mini',
-        name: 'GPT-4o Mini',
-        provider: 'openai',
-        model_family: 'gpt-4',
-        version: '2024-07-18',
-        description: 'Fast and cost-effective model for simple tasks',
-        capabilities: {
-            text_generation: true,
-            text_analysis: true,
-            document_extraction: true,
-            image_understanding: true,
-            function_calling: true,
-            json_mode: true,
-            streaming: true,
-            batch_processing: true,
-            fine_tuning: true,
-            embedding_generation: false,
-            reasoning: true,
-            code_generation: true,
-            multilingual: true,
-            max_context_window: 128000,
-            max_output_tokens: 16384,
-        },
-        limitations: {
-            rate_limits: {
-                requests_per_minute: 30000,
-                tokens_per_minute: 5000000,
-            },
-            content_restrictions: ['NSFW content', 'Illegal activities'],
-            knowledge_cutoff_date: new Date('2024-04-01'),
-        },
-        pricing: {
-            input_tokens_per_1k: 0.00015,
-            output_tokens_per_1k: 0.0006,
-            image_tokens_per_1k: 0.001275,
-            fine_tuning_training_per_1k: 0.003,
-            fine_tuning_usage_per_1k: 0.0012,
-            currency: 'USD',
-            billing_unit: 'token',
-        },
-        performance_benchmarks: {
-            accuracy_scores: {
-                general_text: 0.87,
-                document_extraction: 0.84,
-                reasoning: 0.85,
-                code_generation: 0.83,
-                multilingual: 0.81,
-            },
-            speed_metrics: {
-                average_latency_ms: 800,
-                tokens_per_second: 65,
-                throughput_requests_per_minute: 25000,
-            },
-            reliability_metrics: {
-                uptime_percentage: 99.95,
-                error_rate_percentage: 0.05,
-                consistency_score: 0.89,
-            },
-            cost_efficiency: {
-                cost_per_accurate_response: 0.003,
-                cost_performance_ratio: 28.7,
-            },
-        },
-        technical_specs: {
-            architecture: 'Transformer',
-            inference_hardware: ['GPU'],
-            optimization_techniques: ['Quantization', 'Pruning'],
-            supported_formats: {
-                input: ['text', 'image'],
-                output: ['text', 'json'],
-            },
-            api_compatibility: {
-                openai_compatible: true,
-                custom_endpoints: false,
-                webhook_support: false,
-            },
-        },
-        usage_guidelines: {
-            recommended_use_cases: [
-                'Document extraction',
-                'Text classification',
-                'Simple reasoning',
-                'Batch processing',
-            ],
-            not_recommended_for: [
-                'Complex creative writing',
-                'Advanced mathematical reasoning',
-                'Highly specialized domains',
-            ],
-            best_practices: [
-                'Use for cost-sensitive applications',
-                'Ideal for fine-tuning',
-                'Good for high-volume processing',
-            ],
-            prompt_engineering_tips: [
-                'Keep prompts concise',
-                'Use examples for better performance',
-                'Be specific about requirements',
-            ],
-            parameter_recommendations: {
-                temperature: {
-                    creative_tasks: 0.5,
-                    analytical_tasks: 0.0,
-                    extraction_tasks: 0.0,
-                },
-            },
-            context_window_optimization: [
-                'Use efficient prompt design',
-                'Minimize unnecessary context',
-                'Leverage fine-tuning for domain-specific tasks',
-            ],
-        },
-        supported_features: [
-            'vision',
-            'function_calling',
-            'json_mode',
-            'streaming',
-            'batch',
-            'fine_tuning',
-        ],
-        deprecated: false,
-        created_at: new Date('2024-07-18'),
-        updated_at: new Date('2024-07-18'),
-    },
-};
-export const providerConfigs = {
-    openai: {
-        provider_id: 'openai',
-        provider_name: 'OpenAI',
-        api_base_url: 'https://api.openai.com/v1',
-        authentication: {
-            type: 'api_key',
-            header_name: 'Authorization',
-            header_prefix: 'Bearer',
-        },
-        rate_limiting: {
-            default_rpm: 10000,
-            default_tpm: 2000000,
-            burst_allowance: 100,
-            backoff_strategy: 'exponential',
-        },
-        request_format: {
-            content_type: 'application/json',
-            encoding: 'utf-8',
-            supports_streaming: true,
-            supports_batch: true,
-        },
-        response_format: {
-            content_type: 'application/json',
-            error_format: 'openai',
-            streaming_format: 'text/event-stream',
-        },
-        supported_models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-3.5-turbo'],
-        default_parameters: {
-            temperature: 0.0,
-            max_tokens: 4096,
-        },
-        health_check: {
-            endpoint: '/models',
-            method: 'GET',
-            expected_status: 200,
-            timeout_ms: 5000,
-        },
-    },
-    anthropic: {
-        provider_id: 'anthropic',
-        provider_name: 'Anthropic',
-        api_base_url: 'https://api.anthropic.com',
-        authentication: {
-            type: 'api_key',
-            header_name: 'x-api-key',
-        },
-        rate_limiting: {
-            default_rpm: 4000,
-            default_tpm: 400000,
-            burst_allowance: 50,
-            backoff_strategy: 'exponential',
-        },
-        request_format: {
-            content_type: 'application/json',
-            encoding: 'utf-8',
-            supports_streaming: true,
-            supports_batch: false,
-        },
-        response_format: {
-            content_type: 'application/json',
-            error_format: 'anthropic',
-            streaming_format: 'text/event-stream',
-        },
-        supported_models: ['claude-3-5-sonnet-20241022', 'claude-3-haiku-20240307'],
-        default_parameters: {
-            temperature: 0.0,
-            max_tokens: 4096,
-        },
-        health_check: {
-            endpoint: '/v1/messages',
-            method: 'POST',
-            expected_status: 400, // Expects validation error without proper request
-            timeout_ms: 5000,
-        },
-    },
-};
-// Utility functions
-export class ModelCardManager {
-    constructor() {
-        this.cards = new Map();
-        this.configs = new Map();
-        // Load built-in model cards
-        Object.entries(modelCards).forEach(([id, card]) => {
-            this.cards.set(id, card);
-        });
-        // Load built-in provider configs
-        Object.entries(providerConfigs).forEach(([id, config]) => {
-            this.configs.set(id, config);
-        });
-    }
-    static getInstance() {
-        if (!ModelCardManager.instance) {
-            ModelCardManager.instance = new ModelCardManager();
-        }
-        return ModelCardManager.instance;
-    }
-    getModelCard(modelId) {
-        return this.cards.get(modelId);
-    }
-    getProviderConfig(providerId) {
-        return this.configs.get(providerId);
-    }
-    getAllModels() {
-        return Array.from(this.cards.values());
-    }
-    getModelsByProvider(providerId) {
-        return Array.from(this.cards.values()).filter(card => card.provider === providerId);
-    }
-    recommendModel(criteria) {
-        const models = Array.from(this.cards.values());
-        const recommendations = [];
-        for (const model of models) {
-            let score = 0;
-            const rationale = [];
-            // Check basic requirements
-            if (criteria.context_length_required > model.capabilities.max_context_window)
-                continue;
-            if (criteria.output_length_required > model.capabilities.max_output_tokens)
-                continue;
-            if (criteria.supports_images && !model.capabilities.image_understanding)
-                continue;
-            if (criteria.supports_function_calling && !model.capabilities.function_calling)
-                continue;
-            if (criteria.supports_json_mode && !model.capabilities.json_mode)
-                continue;
-            // Score based on priorities
-            const accuracy = model.performance_benchmarks.accuracy_scores.general_text;
-            const speed = 1 / (model.performance_benchmarks.speed_metrics.average_latency_ms / 1000);
-            const cost = 1 / model.pricing.input_tokens_per_1k;
-            switch (criteria.accuracy_priority) {
-                case 'critical':
-                    score += accuracy * 0.5;
-                    break;
-                case 'high':
-                    score += accuracy * 0.35;
-                    break;
-                case 'medium':
-                    score += accuracy * 0.2;
-                    break;
-                case 'low':
-                    score += accuracy * 0.1;
-                    break;
-            }
-            switch (criteria.speed_priority) {
-                case 'critical':
-                    score += speed * 0.3;
-                    break;
-                case 'high':
-                    score += speed * 0.2;
-                    break;
-                case 'medium':
-                    score += speed * 0.15;
-                    break;
-                case 'low':
-                    score += speed * 0.05;
-                    break;
-            }
-            switch (criteria.cost_priority) {
-                case 'critical':
-                    score += cost * 0.3;
-                    break;
-                case 'high':
-                    score += cost * 0.2;
-                    break;
-                case 'medium':
-                    score += cost * 0.15;
-                    break;
-                case 'low':
-                    score += cost * 0.05;
-                    break;
-            }
-            if (score > 0.3) { // Minimum threshold
-                recommendations.push({
-                    model_id: model.id,
-                    model_name: model.name,
-                    provider: model.provider,
-                    confidence_score: Math.min(score, 1.0),
-                    rationale,
-                    expected_performance: {
-                        accuracy: accuracy,
-                        latency_ms: model.performance_benchmarks.speed_metrics.average_latency_ms,
-                        cost_per_request: model.pricing.input_tokens_per_1k * 0.5, // Rough estimate
-                    },
-                    trade_offs: [],
-                    alternative_models: [],
-                });
-            }
-        }
-        return recommendations.sort((a, b) => b.confidence_score - a.confidence_score);
-    }
-    addModelCard(card) {
-        this.cards.set(card.id, card);
-    }
-    updateModelCard(modelId, updates) {
-        const existing = this.cards.get(modelId);
-        if (existing) {
-            this.cards.set(modelId, { ...existing, ...updates, updated_at: new Date() });
-        }
-    }
-}
-// Export values but not types in default export
-export default {
-    ModelCardManager,
-    modelCards,
-    providerConfigs,
-};

package/dist/utils/prompt_optimization.d.ts

@@ -1,96 +0,0 @@
-/**
- * Prompt optimization utilities for improving AI model performance
- * Equivalent to Python's prompt_optimization.py
- */
-export interface PromptOptimizationConfig {
-    maxTokens?: number;
-    temperature?: number;
-    model?: string;
-    preserveStructure?: boolean;
-    optimizationGoal?: 'accuracy' | 'speed' | 'cost' | 'balanced';
-}
-export interface PromptMetrics {
-    tokenCount: number;
-    clarity: number;
-    specificity: number;
-    complexity: number;
-    estimatedCost: number;
-    estimatedLatency: number;
-}
-export interface OptimizationResult {
-    originalPrompt: string;
-    optimizedPrompt: string;
-    improvements: string[];
-    metrics: {
-        before: PromptMetrics;
-        after: PromptMetrics;
-    };
-    confidence: number;
-}
-/**
- * Estimate token count for a prompt (rough approximation)
- */
-export declare function estimateTokenCount(text: string): number;
-/**
- * Calculate prompt clarity score based on readability metrics
- */
-export declare function calculateClarity(prompt: string): number;
-/**
- * Calculate prompt specificity score
- */
-export declare function calculateSpecificity(prompt: string): number;
-/**
- * Calculate prompt complexity score
- */
-export declare function calculateComplexity(prompt: string): number;
-/**
- * Estimate cost based on token count and model
- */
-export declare function estimateCost(tokenCount: number, model?: string): number;
-/**
- * Estimate latency based on token count and model
- */
-export declare function estimateLatency(tokenCount: number, model?: string): number;
-/**
- * Calculate comprehensive prompt metrics
- */
-export declare function calculateMetrics(prompt: string, model?: string): PromptMetrics;
-/**
- * Optimize prompt for brevity while maintaining clarity
- */
-export declare function optimizeForBrevity(prompt: string): string;
-/**
- * Optimize prompt for clarity and structure
- */
-export declare function optimizeForClarity(prompt: string): string;
-/**
- * Optimize prompt for specific AI model characteristics
- */
-export declare function optimizeForModel(prompt: string, model: string): string;
-/**
- * Main optimization function
- */
-export declare function optimizePrompt(prompt: string, config?: PromptOptimizationConfig): OptimizationResult;
-/**
- * Test prompt variations and return the best one
- */
-export declare function testPromptVariations(basePrompt: string, variations: string[], testFunction: (prompt: string) => Promise<number>, // Should return a score
-config?: PromptOptimizationConfig): Promise<OptimizationResult & {
-    score: number;
-}>;
-declare const _default: {
-    estimateTokenCount: typeof estimateTokenCount;
-    calculateClarity: typeof calculateClarity;
-    calculateSpecificity: typeof calculateSpecificity;
-    calculateComplexity: typeof calculateComplexity;
-    estimateCost: typeof estimateCost;
-    estimateLatency: typeof estimateLatency;
-    calculateMetrics: typeof calculateMetrics;
-    optimizeForBrevity: typeof optimizeForBrevity;
-    optimizeForClarity: typeof optimizeForClarity;
-    optimizeForModel: typeof optimizeForModel;
-    optimizePrompt: typeof optimizePrompt;
-    testPromptVariations: typeof testPromptVariations;
-};
-export default _default;
-//# sourceMappingURL=prompt_optimization.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompt_optimization.d.ts","sourceRoot":"","sources":["../../src/utils/prompt_optimization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,CAAC;CAC/D;AAED,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE;QACP,MAAM,EAAE,aAAa,CAAC;QACtB,KAAK,EAAE,aAAa,CAAC;KACtB,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAevD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAa3D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAgB1D;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAsB,GAAG,MAAM,CActF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,GAAE,MAAsB,GAAG,MAAM,CAczF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,GAAE,MAAsB,GAAG,aAAa,CAW7F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAczD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CA8BzD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CA6BtE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,MAAM,GAAE,wBAA6B,GACpC,kBAAkB,CA6DpB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAAE,EACpB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAAE,wBAAwB;AAC3E,MAAM,GAAE,wBAA6B,GACpC,OAAO,CAAC,kBAAkB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAuCjD;;;;;;;;;;;;;;;AAED,wBAaE"}