@codebolt/agent 5.0.1 → 5.0.6

package/dist/processor-pieces/postToolCall/telemetryProcessor.js

@@ -1,278 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryProcessor = void 0;
-const processor_1 = require("../../processor");
-class TelemetryProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super();
-        // Metrics storage
-        this.performanceMetrics = [];
-        this.errorMetrics = [];
-        this.usageMetrics = [];
-        this.tokenMetrics = [];
-        this.operationTimers = new Map();
-        this.enablePerformanceTracking = options.enablePerformanceTracking !== false;
-        this.enableErrorTracking = options.enableErrorTracking !== false;
-        this.enableUsageTracking = options.enableUsageTracking !== false;
-        this.enableTokenTracking = options.enableTokenTracking !== false;
-        this.sampleRate = options.sampleRate || 1.0;
-        this.batchSize = options.batchSize || 100;
-        this.flushInterval = options.flushInterval || 60000; // 1 minute
-        this.enableLocalStorage = options.enableLocalStorage !== false;
-        this.exportPath = options.exportPath || './telemetry';
-        this.sessionId = this.generateSessionId();
-        this.startTime = Date.now();
-        // Setup periodic flush
-        if (this.flushInterval > 0) {
-            this.flushTimer = setInterval(() => {
-                this.flushMetrics().catch(console.error);
-            }, this.flushInterval);
-        }
-    }
-    async processInput(input) {
-        var _a;
-        const { message, context } = input;
-        // Sample based on rate
-        if (Math.random() > this.sampleRate) {
-            return [];
-        }
-        const results = [];
-        try {
-            // Track processing performance
-            if (this.enablePerformanceTracking) {
-                this.startOperation('message_processing');
-            }
-            // Track usage
-            if (this.enableUsageTracking) {
-                this.trackUsage('message_processed', context === null || context === void 0 ? void 0 : context.userId, this.sessionId);
-            }
-            // Track token usage if available
-            if (this.enableTokenTracking && (context === null || context === void 0 ? void 0 : context.tokenUsage)) {
-                this.trackTokens(((_a = context.llmconfig) === null || _a === void 0 ? void 0 : _a.model) || 'unknown', context.tokenUsage.input || 0, context.tokenUsage.output || 0, context.tokenUsage.cached || 0, context.tokenUsage.cost);
-            }
-            // Track tool usage
-            if (this.enableUsageTracking && message.messages) {
-                for (const msg of message.messages) {
-                    if (msg.tool_calls && msg.tool_calls.length > 0) {
-                        for (const toolCall of msg.tool_calls) {
-                            this.trackUsage(`tool_${toolCall.function.name}`, context === null || context === void 0 ? void 0 : context.userId, this.sessionId);
-                        }
-                    }
-                }
-            }
-            results.push(this.createEvent('TelemetryRecorded', {
-                sessionId: this.sessionId,
-                metricsCount: this.getTotalMetricsCount()
-            }));
-            // Check if we need to flush
-            if (this.getTotalMetricsCount() >= this.batchSize) {
-                await this.flushMetrics();
-                results.push(this.createEvent('TelemetryFlushed', {
-                    sessionId: this.sessionId,
-                    reason: 'batch_size_reached'
-                }));
-            }
-        }
-        catch (error) {
-            if (this.enableErrorTracking) {
-                this.trackError('telemetry_processing_error', error instanceof Error ? error.message : String(error), error instanceof Error ? error.stack : undefined, { messageType: typeof message, contextKeys: context ? Object.keys(context) : [] });
-            }
-            results.push(this.createEvent('TelemetryError', {
-                error: error instanceof Error ? error.message : String(error)
-            }));
-        }
-        finally {
-            if (this.enablePerformanceTracking) {
-                this.endOperation('message_processing', true);
-            }
-        }
-        return results;
-    }
-    // Performance tracking methods
-    startOperation(operation) {
-        if (!this.enablePerformanceTracking)
-            return;
-        this.operationTimers.set(operation, Date.now());
-    }
-    endOperation(operation, success, metadata) {
-        if (!this.enablePerformanceTracking)
-            return;
-        const startTime = this.operationTimers.get(operation);
-        if (startTime === undefined)
-            return;
-        const endTime = Date.now();
-        const duration = endTime - startTime;
-        this.performanceMetrics.push({
-            operation,
-            startTime,
-            endTime,
-            duration,
-            success,
-            metadata
-        });
-        this.operationTimers.delete(operation);
-    }
-    // Error tracking methods
-    trackError(type, message, stack, context) {
-        if (!this.enableErrorTracking)
-            return;
-        this.errorMetrics.push({
-            type,
-            message,
-            stack,
-            timestamp: Date.now(),
-            context
-        });
-    }
-    // Usage tracking methods
-    trackUsage(feature, userId, sessionId) {
-        if (!this.enableUsageTracking)
-            return;
-        // Check if we already have a metric for this feature in the current batch
-        const existingMetric = this.usageMetrics.find(m => m.feature === feature &&
-            m.userId === userId &&
-            m.sessionId === sessionId &&
-            Date.now() - m.timestamp < 60000 // Within last minute
-        );
-        if (existingMetric) {
-            existingMetric.count++;
-        }
-        else {
-            this.usageMetrics.push({
-                feature,
-                count: 1,
-                timestamp: Date.now(),
-                userId,
-                sessionId: sessionId || this.sessionId
-            });
-        }
-    }
-    // Token tracking methods
-    trackTokens(model, inputTokens, outputTokens, cachedTokens = 0, cost) {
-        if (!this.enableTokenTracking)
-            return;
-        this.tokenMetrics.push({
-            model,
-            inputTokens,
-            outputTokens,
-            cachedTokens,
-            totalTokens: inputTokens + outputTokens + cachedTokens,
-            timestamp: Date.now(),
-            cost
-        });
-    }
-    // Flush methods
-    async flushMetrics() {
-        if (!this.enableLocalStorage)
-            return;
-        const telemetryData = {
-            sessionId: this.sessionId,
-            timestamp: Date.now(),
-            performance: [...this.performanceMetrics],
-            errors: [...this.errorMetrics],
-            usage: [...this.usageMetrics],
-            tokens: [...this.tokenMetrics],
-            metadata: {
-                sessionStartTime: this.startTime,
-                flushTime: Date.now(),
-                totalOperationsTracked: this.performanceMetrics.length,
-                totalErrorsTracked: this.errorMetrics.length,
-                totalUsageEvents: this.usageMetrics.length,
-                totalTokenEvents: this.tokenMetrics.length
-            }
-        };
-        try {
-            // In a real implementation, you would send this to a telemetry service
-            // For now, we'll just log it and optionally save to file
-            console.log('[Telemetry] Flushing metrics:', {
-                sessionId: this.sessionId,
-                metricsCount: this.getTotalMetricsCount()
-            });
-            if (this.enableLocalStorage) {
-                await this.saveToFile(telemetryData);
-            }
-            // Clear metrics after successful flush
-            this.clearMetrics();
-        }
-        catch (error) {
-            console.error('[Telemetry] Error flushing metrics:', error);
-            throw error;
-        }
-    }
-    async saveToFile(data) {
-        try {
-            const fs = await import('fs/promises');
-            const path = await import('path');
-            // Ensure directory exists
-            try {
-                await fs.access(this.exportPath);
-            }
-            catch {
-                await fs.mkdir(this.exportPath, { recursive: true });
-            }
-            const filename = `telemetry-${this.sessionId}-${Date.now()}.json`;
-            const filepath = path.join(this.exportPath, filename);
-            await fs.writeFile(filepath, JSON.stringify(data, null, 2), 'utf-8');
-        }
-        catch (error) {
-            console.error('[Telemetry] Error saving to file:', error);
-        }
-    }
-    clearMetrics() {
-        this.performanceMetrics = [];
-        this.errorMetrics = [];
-        this.usageMetrics = [];
-        this.tokenMetrics = [];
-    }
-    getTotalMetricsCount() {
-        return this.performanceMetrics.length +
-            this.errorMetrics.length +
-            this.usageMetrics.length +
-            this.tokenMetrics.length;
-    }
-    generateSessionId() {
-        return `telemetry-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    // Public methods for getting metrics
-    getMetricsSummary() {
-        return {
-            sessionId: this.sessionId,
-            sessionDuration: Date.now() - this.startTime,
-            performance: this.performanceMetrics.length,
-            errors: this.errorMetrics.length,
-            usage: this.usageMetrics.length,
-            tokens: this.tokenMetrics.length,
-            total: this.getTotalMetricsCount()
-        };
-    }
-    getPerformanceStats() {
-        if (this.performanceMetrics.length === 0) {
-            return {
-                averageDuration: 0,
-                successRate: 0,
-                slowestOperation: null,
-                fastestOperation: null
-            };
-        }
-        const totalDuration = this.performanceMetrics.reduce((sum, m) => sum + m.duration, 0);
-        const successCount = this.performanceMetrics.filter(m => m.success).length;
-        const sortedByDuration = [...this.performanceMetrics].sort((a, b) => a.duration - b.duration);
-        return {
-            averageDuration: totalDuration / this.performanceMetrics.length,
-            successRate: successCount / this.performanceMetrics.length,
-            slowestOperation: sortedByDuration[sortedByDuration.length - 1] || null,
-            fastestOperation: sortedByDuration[0] || null
-        };
-    }
-    // Cleanup
-    async destroy() {
-        if (this.flushTimer) {
-            clearInterval(this.flushTimer);
-        }
-        // Final flush
-        if (this.getTotalMetricsCount() > 0) {
-            await this.flushMetrics();
-        }
-    }
-}
-exports.TelemetryProcessor = TelemetryProcessor;

package/dist/processor-pieces/postToolCall/tokenManagementProcessor.d.ts

@@ -1,37 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface TokenManagementProcessorOptions {
-    maxTokens?: number;
-    warningThreshold?: number;
-    enableCompression?: boolean;
-    compressionThreshold?: number;
-    enableCaching?: boolean;
-    modelTokenLimits?: Record<string, number>;
-}
-export interface TokenUsage {
-    input: number;
-    output: number;
-    cached: number;
-    total: number;
-    estimated?: boolean;
-}
-export declare class TokenManagementProcessor extends BaseProcessor {
-    private readonly maxTokens;
-    private readonly warningThreshold;
-    private readonly enableCompression;
-    private readonly compressionThreshold;
-    private readonly enableCaching;
-    private readonly modelTokenLimits;
-    private tokenCache;
-    constructor(options?: TokenManagementProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private calculateTokenUsage;
-    private extractTextFromMessage;
-    private estimateTokens;
-    private getCacheKey;
-    getTokenUsageStats(): {
-        cacheSize: number;
-        cacheHitRate: number;
-        averageTokensPerMessage: number;
-    };
-    clearCache(): void;
-}

package/dist/processor-pieces/postToolCall/tokenManagementProcessor.js

@@ -1,178 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenManagementProcessor = void 0;
-const processor_1 = require("../../processor");
-class TokenManagementProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super();
-        // Token cache for performance
-        this.tokenCache = new Map();
-        this.maxTokens = options.maxTokens || 128000;
-        this.warningThreshold = options.warningThreshold || 0.8;
-        this.enableCompression = options.enableCompression !== false;
-        this.compressionThreshold = options.compressionThreshold || 0.7;
-        this.enableCaching = options.enableCaching !== false;
-        this.modelTokenLimits = options.modelTokenLimits || {
-            'gemini-pro': 128000,
-            'gemini-pro-vision': 128000,
-            'gemini-flash': 1000000,
-            'gpt-4': 128000,
-            'gpt-3.5-turbo': 16385,
-            'claude-3': 200000
-        };
-    }
-    async processInput(input) {
-        var _a, _b;
-        const { message, context } = input;
-        try {
-            // Calculate current token usage
-            const tokenUsage = await this.calculateTokenUsage(message);
-            // Get model-specific limit if available
-            const modelName = ((_a = context === null || context === void 0 ? void 0 : context.llmconfig) === null || _a === void 0 ? void 0 : _a.model) || ((_b = context === null || context === void 0 ? void 0 : context.llmconfig) === null || _b === void 0 ? void 0 : _b.llmname) || 'gemini-pro';
-            const modelLimit = this.modelTokenLimits[modelName] || this.maxTokens;
-            const results = [];
-            // Add token usage information
-            results.push(this.createEvent('TokenUsageCalculated', {
-                usage: tokenUsage,
-                modelLimit,
-                utilizationPercentage: (tokenUsage.total / modelLimit) * 100
-            }));
-            // Check if we're approaching token limits
-            if (tokenUsage.total > modelLimit * this.warningThreshold) {
-                results.push(this.createEvent('TokenLimitWarning', {
-                    usage: tokenUsage,
-                    limit: modelLimit,
-                    warningThreshold: this.warningThreshold,
-                    recommendation: this.enableCompression ? 'compression_suggested' : 'trim_history'
-                }));
-            }
-            // Check if we need compression
-            if (this.enableCompression && tokenUsage.total > modelLimit * this.compressionThreshold) {
-                results.push(this.createEvent('CompressionTriggered', {
-                    usage: tokenUsage,
-                    limit: modelLimit,
-                    compressionThreshold: this.compressionThreshold
-                }));
-            }
-            // Check if we're over the limit
-            if (tokenUsage.total > modelLimit) {
-                results.push(this.createEvent('TokenLimitExceeded', {
-                    usage: tokenUsage,
-                    limit: modelLimit,
-                    excessTokens: tokenUsage.total - modelLimit,
-                    action: 'truncation_required'
-                }));
-            }
-            return results;
-        }
-        catch (error) {
-            console.error('[TokenManagement] Error calculating tokens:', error);
-            return [this.createEvent('TokenCalculationError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    fallbackEstimate: this.estimateTokens(message)
-                })];
-        }
-    }
-    async calculateTokenUsage(message) {
-        try {
-            // Try to use CodeBolt's LLM service for accurate token counting
-            const messagesText = this.extractTextFromMessage(message);
-            // Check cache first
-            if (this.enableCaching) {
-                const cacheKey = this.getCacheKey(messagesText);
-                const cachedCount = this.tokenCache.get(cacheKey);
-                if (cachedCount !== undefined) {
-                    return {
-                        input: cachedCount,
-                        output: 0,
-                        cached: cachedCount,
-                        total: cachedCount
-                    };
-                }
-            }
-            // For now, use estimation since we don't have direct access to token counting
-            // In a real implementation, you would use codebolt.llm.countTokens() or similar
-            const estimatedTokens = this.estimateTokens(message);
-            // Cache the result
-            if (this.enableCaching) {
-                const cacheKey = this.getCacheKey(messagesText);
-                this.tokenCache.set(cacheKey, estimatedTokens);
-                // Limit cache size
-                if (this.tokenCache.size > 1000) {
-                    const firstKey = this.tokenCache.keys().next().value;
-                    if (firstKey !== undefined) {
-                        this.tokenCache.delete(firstKey);
-                    }
-                }
-            }
-            return {
-                input: estimatedTokens,
-                output: 0,
-                cached: 0,
-                total: estimatedTokens,
-                estimated: true
-            };
-        }
-        catch (error) {
-            console.error('[TokenManagement] Token calculation failed:', error);
-            const fallbackEstimate = this.estimateTokens(message);
-            return {
-                input: fallbackEstimate,
-                output: 0,
-                cached: 0,
-                total: fallbackEstimate,
-                estimated: true
-            };
-        }
-    }
-    extractTextFromMessage(message) {
-        if (typeof message === 'string') {
-            return message;
-        }
-        if ((message === null || message === void 0 ? void 0 : message.messages) && Array.isArray(message.messages)) {
-            return message.messages
-                .map((msg) => {
-                if (typeof msg.content === 'string') {
-                    return msg.content;
-                }
-                if (Array.isArray(msg.content)) {
-                    return msg.content
-                        .filter((part) => part.type === 'text' || typeof part === 'string')
-                        .map((part) => typeof part === 'string' ? part : part.text)
-                        .join(' ');
-                }
-                return JSON.stringify(msg.content);
-            })
-                .join('\n');
-        }
-        return JSON.stringify(message);
-    }
-    estimateTokens(message) {
-        const text = this.extractTextFromMessage(message);
-        // Rough estimation: ~4 characters per token for English text
-        // This is a simplified estimation - real tokenizers are more complex
-        const charCount = text.length;
-        const wordCount = text.split(/\s+/).length;
-        // Use a combination of character and word count for better estimation
-        const charBasedEstimate = Math.ceil(charCount / 4);
-        const wordBasedEstimate = Math.ceil(wordCount * 1.3); // Account for subword tokens
-        // Use the higher estimate to be conservative
-        return Math.max(charBasedEstimate, wordBasedEstimate);
-    }
-    getCacheKey(text) {
-        // Create a hash-like key for caching
-        return text.length.toString() + '_' + text.slice(0, 100).replace(/\s+/g, '');
-    }
-    getTokenUsageStats() {
-        // In a real implementation, you would track these statistics
-        return {
-            cacheSize: this.tokenCache.size,
-            cacheHitRate: 0, // Would track cache hits vs misses
-            averageTokensPerMessage: 0 // Would track running average
-        };
-    }
-    clearCache() {
-        this.tokenCache.clear();
-    }
-}
-exports.TokenManagementProcessor = TokenManagementProcessor;

package/dist/processor-pieces/postToolCall/toolExecutionProcessor.d.ts

@@ -1,43 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ToolExecutionInfo {
-    toolCall: any;
-    toolName: string;
-    toolbox: string;
-    parameters: Record<string, any>;
-    needsConfirmation: boolean;
-    confirmed?: boolean;
-}
-export interface ToolExecutionResult {
-    toolCallId: string;
-    result: any;
-    error?: string;
-    success: boolean;
-    executionTime: number;
-}
-export interface ToolExecutionProcessorOptions {
-    enableToolConfirmation?: boolean;
-    maxRetries?: number;
-    retryDelay?: number;
-    enableLogging?: boolean;
-}
-export declare class ToolExecutionProcessor extends BaseProcessor {
-    private readonly enableToolConfirmation;
-    private readonly maxRetries;
-    private readonly retryDelay;
-    private readonly enableLogging;
-    private executedTools;
-    constructor(options?: ToolExecutionProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private extractToolCalls;
-    private processToolCall;
-    private shouldConfirmTool;
-    private executeTool;
-    private calculateSuccessRate;
-    confirmToolExecution(toolCallId: string, confirmed: boolean): Promise<void>;
-    getToolExecutionHistory(): ToolExecutionResult[];
-    clearToolHistory(): void;
-    setMaxRetries(maxRetries: number): void;
-    setRetryDelay(delay: number): void;
-    enableLoggingForSession(): void;
-    disableLoggingForSession(): void;
-}