@codebolt/agent 2.2.2 → 2.2.3

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

@@ -0,0 +1,99 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface TelemetryProcessorOptions {
+    enablePerformanceTracking?: boolean;
+    enableErrorTracking?: boolean;
+    enableUsageTracking?: boolean;
+    enableTokenTracking?: boolean;
+    sampleRate?: number;
+    batchSize?: number;
+    flushInterval?: number;
+    enableLocalStorage?: boolean;
+    exportPath?: string;
+}
+export interface PerformanceMetric {
+    operation: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    success: boolean;
+    metadata?: Record<string, any>;
+}
+export interface ErrorMetric {
+    type: string;
+    message: string;
+    stack?: string;
+    timestamp: number;
+    context?: Record<string, any>;
+}
+export interface UsageMetric {
+    feature: string;
+    count: number;
+    timestamp: number;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TokenMetric {
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    totalTokens: number;
+    timestamp: number;
+    cost?: number;
+}
+export interface TelemetryData {
+    sessionId: string;
+    timestamp: number;
+    performance: PerformanceMetric[];
+    errors: ErrorMetric[];
+    usage: UsageMetric[];
+    tokens: TokenMetric[];
+    metadata: Record<string, any>;
+}
+export declare class TelemetryProcessor extends BaseProcessor {
+    private readonly enablePerformanceTracking;
+    private readonly enableErrorTracking;
+    private readonly enableUsageTracking;
+    private readonly enableTokenTracking;
+    private readonly sampleRate;
+    private readonly batchSize;
+    private readonly flushInterval;
+    private readonly enableLocalStorage;
+    private readonly exportPath;
+    private performanceMetrics;
+    private errorMetrics;
+    private usageMetrics;
+    private tokenMetrics;
+    private sessionId;
+    private startTime;
+    private operationTimers;
+    private flushTimer?;
+    constructor(options?: TelemetryProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    startOperation(operation: string): void;
+    endOperation(operation: string, success: boolean, metadata?: Record<string, any>): void;
+    trackError(type: string, message: string, stack?: string, context?: Record<string, any>): void;
+    trackUsage(feature: string, userId?: string, sessionId?: string): void;
+    trackTokens(model: string, inputTokens: number, outputTokens: number, cachedTokens?: number, cost?: number): void;
+    flushMetrics(): Promise<void>;
+    private saveToFile;
+    private clearMetrics;
+    private getTotalMetricsCount;
+    private generateSessionId;
+    getMetricsSummary(): {
+        sessionId: string;
+        sessionDuration: number;
+        performance: number;
+        errors: number;
+        usage: number;
+        tokens: number;
+        total: number;
+    };
+    getPerformanceStats(): {
+        averageDuration: number;
+        successRate: number;
+        slowestOperation: PerformanceMetric | null;
+        fastestOperation: PerformanceMetric | null;
+    };
+    destroy(): Promise<void>;
+}

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

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

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

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

@@ -0,0 +1,43 @@
+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;
+}