@codebolt/agent 1.2.1 → 2.2.2

package/dist/processor-pieces/processors/responseValidationProcessor.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseValidationProcessor = void 0;
+const processor_1 = require("../../processor");
+class ResponseValidationProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super();
+        this.enableToolCallValidation = options.validateToolCalls !== false;
+        this.validateContent = options.validateContent !== false;
+        this.validateStructure = options.validateStructure !== false;
+        this.allowEmptyContent = options.allowEmptyContent || false;
+        this.maxContentLength = options.maxContentLength || 100000;
+        this.requiredFields = options.requiredFields || ['role'];
+    }
+    async processInput(input) {
+        var _a;
+        const { message } = input;
+        const validationResult = this.validateMessage(message);
+        const results = [
+            this.createEvent('ValidationCompleted', {
+                result: validationResult,
+                messageId: ((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.id) || 'unknown'
+            })
+        ];
+        if (!validationResult.isValid) {
+            results.push(this.createEvent('ValidationFailed', {
+                errors: validationResult.errors,
+                warnings: validationResult.warnings,
+                fixes: validationResult.fixes
+            }));
+        }
+        if (validationResult.warnings.length > 0) {
+            results.push(this.createEvent('ValidationWarnings', {
+                warnings: validationResult.warnings
+            }));
+        }
+        return results;
+    }
+    validateMessage(message) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Structure validation
+        if (this.validateStructure) {
+            const structureValidation = this.validateMessageStructure(message);
+            errors.push(...structureValidation.errors);
+            warnings.push(...structureValidation.warnings);
+            fixes.push(...structureValidation.fixes);
+        }
+        // Content validation
+        if (this.validateContent && message.messages) {
+            for (let i = 0; i < message.messages.length; i++) {
+                const msg = message.messages[i];
+                const contentValidation = this.validateMessageContent(msg, i);
+                errors.push(...contentValidation.errors);
+                warnings.push(...contentValidation.warnings);
+                fixes.push(...contentValidation.fixes);
+            }
+        }
+        // Tool calls validation
+        if (this.enableToolCallValidation && message.messages) {
+            for (let i = 0; i < message.messages.length; i++) {
+                const msg = message.messages[i];
+                if (msg.tool_calls) {
+                    const toolValidation = this.validateToolCallsInMessage(msg.tool_calls, i);
+                    errors.push(...toolValidation.errors);
+                    warnings.push(...toolValidation.warnings);
+                    fixes.push(...toolValidation.fixes);
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            fixes
+        };
+    }
+    validateMessageStructure(message) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Check if message exists
+        if (!message) {
+            errors.push('Message is null or undefined');
+            fixes.push('Provide a valid message object');
+            return { isValid: false, errors, warnings, fixes };
+        }
+        // Check if messages array exists
+        if (!message.messages) {
+            errors.push('Message object missing required "messages" array');
+            fixes.push('Add a "messages" array to the message object');
+        }
+        else if (!Array.isArray(message.messages)) {
+            errors.push('Messages field must be an array');
+            fixes.push('Convert messages field to an array');
+        }
+        else if (message.messages.length === 0) {
+            warnings.push('Messages array is empty');
+        }
+        // Check metadata structure
+        if (message.metadata && typeof message.metadata !== 'object') {
+            warnings.push('Metadata should be an object');
+            fixes.push('Convert metadata to an object or remove it');
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    validateMessageContent(msg, index) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Check required fields
+        for (const field of this.requiredFields) {
+            if (!(field in msg)) {
+                errors.push(`Message at index ${index} missing required field: ${field}`);
+                fixes.push(`Add ${field} field to message at index ${index}`);
+            }
+        }
+        // Validate role
+        if (msg.role) {
+            const validRoles = ['user', 'assistant', 'system', 'tool'];
+            if (!validRoles.includes(msg.role)) {
+                errors.push(`Invalid role "${msg.role}" at index ${index}. Must be one of: ${validRoles.join(', ')}`);
+                fixes.push(`Change role to one of: ${validRoles.join(', ')}`);
+            }
+        }
+        // Validate content
+        if (msg.content !== undefined) {
+            if (typeof msg.content === 'string') {
+                // String content validation
+                if (!this.allowEmptyContent && msg.content.trim() === '') {
+                    warnings.push(`Empty content in message at index ${index}`);
+                    fixes.push('Provide meaningful content or remove the message');
+                }
+                if (msg.content.length > this.maxContentLength) {
+                    warnings.push(`Content too long at index ${index}: ${msg.content.length} chars (max: ${this.maxContentLength})`);
+                    fixes.push('Truncate or compress the content');
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                // Array content validation (for multimodal messages)
+                for (let partIndex = 0; partIndex < msg.content.length; partIndex++) {
+                    const part = msg.content[partIndex];
+                    if (!part || (typeof part !== 'object' && typeof part !== 'string')) {
+                        errors.push(`Invalid content part at message ${index}, part ${partIndex}`);
+                        fixes.push('Ensure all content parts are valid objects or strings');
+                    }
+                }
+            }
+            else if (typeof msg.content !== 'object') {
+                warnings.push(`Unexpected content type at index ${index}: ${typeof msg.content}`);
+            }
+        }
+        // Validate name field
+        if (msg.name && typeof msg.name !== 'string') {
+            warnings.push(`Name field should be a string at index ${index}`);
+            fixes.push('Convert name field to string');
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    validateToolCallsInMessage(toolCalls, messageIndex) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        if (!Array.isArray(toolCalls)) {
+            errors.push(`Tool calls must be an array at message index ${messageIndex}`);
+            fixes.push('Convert tool_calls to an array');
+            return { isValid: false, errors, warnings, fixes };
+        }
+        for (let i = 0; i < toolCalls.length; i++) {
+            const toolCall = toolCalls[i];
+            // Check required tool call fields
+            if (!toolCall.id) {
+                errors.push(`Tool call at message ${messageIndex}, call ${i} missing required "id" field`);
+                fixes.push('Add unique id to tool call');
+            }
+            if (!toolCall.function) {
+                errors.push(`Tool call at message ${messageIndex}, call ${i} missing required "function" field`);
+                fixes.push('Add function object to tool call');
+            }
+            else {
+                // Validate function object
+                if (!toolCall.function.name) {
+                    errors.push(`Tool call function at message ${messageIndex}, call ${i} missing "name" field`);
+                    fixes.push('Add function name to tool call');
+                }
+                if (toolCall.function.arguments === undefined) {
+                    warnings.push(`Tool call function at message ${messageIndex}, call ${i} missing "arguments" field`);
+                    fixes.push('Add arguments field (can be empty object)');
+                }
+                else {
+                    // Validate arguments
+                    if (typeof toolCall.function.arguments === 'string') {
+                        try {
+                            JSON.parse(toolCall.function.arguments);
+                        }
+                        catch (e) {
+                            errors.push(`Invalid JSON in tool call arguments at message ${messageIndex}, call ${i}`);
+                            fixes.push('Ensure arguments are valid JSON string or object');
+                        }
+                    }
+                    else if (typeof toolCall.function.arguments !== 'object') {
+                        warnings.push(`Tool call arguments should be object or JSON string at message ${messageIndex}, call ${i}`);
+                    }
+                }
+            }
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    // Utility method to get validation summary
+    getValidationSummary(validationResult) {
+        const summary = [];
+        if (validationResult.isValid) {
+            summary.push('✅ Validation passed');
+        }
+        else {
+            summary.push('❌ Validation failed');
+        }
+        if (validationResult.errors.length > 0) {
+            summary.push(`${validationResult.errors.length} error(s)`);
+        }
+        if (validationResult.warnings.length > 0) {
+            summary.push(`${validationResult.warnings.length} warning(s)`);
+        }
+        return summary.join(' - ');
+    }
+}
+exports.ResponseValidationProcessor = ResponseValidationProcessor;

package/dist/processor-pieces/processors/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/processors/telemetryProcessor.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const path = await Promise.resolve().then(() => __importStar(require('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/processors/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;
+}