@codebolt/agent 5.0.1 → 5.0.6

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

@@ -1,137 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoopDetectionProcessor = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class LoopDetectionProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.lastPromptId = null;
-        this.loopCount = 0;
-        this.maxLoops = options.maxLoops || 3;
-        this.messageThreshold = options.messageThreshold || 6;
-        this.enableLoopDetection = options.enableLoopDetection !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            if (!this.enableLoopDetection) {
-                return [this.createEvent('LoopDetectionDisabled', {
-                        reason: 'Loop detection is disabled for this session'
-                    })];
-            }
-            // Get prompt ID from context or generate one
-            const promptId = (context === null || context === void 0 ? void 0 : context.promptId) || this.generatePromptId();
-            // Reset loop detector if new prompt
-            if (this.lastPromptId !== promptId) {
-                await this.resetLoopDetector(promptId);
-                this.lastPromptId = promptId;
-            }
-            else {
-                this.loopCount++;
-            }
-            // Check for conversation loops using CodeBolt state
-            const loopDetected = await this.checkLoopDetection();
-            if (loopDetected) {
-                // Send notification about loop detection
-                await codeboltjs_1.default.chat.sendNotificationEvent('Loop detected in conversation', 'debug');
-                return [this.createEvent('LoopDetected', {
-                        promptId,
-                        loopCount: this.loopCount,
-                        maxLoops: this.maxLoops
-                    })];
-            }
-            // Check if max loops reached
-            if (this.loopCount > this.maxLoops) {
-                return [this.createEvent('MaxLoopsReached', {
-                        promptId,
-                        loopCount: this.loopCount,
-                        maxLoops: this.maxLoops
-                    })];
-            }
-            // Continue processing
-            return [this.createEvent('LoopDetectionPassed', {
-                    promptId,
-                    loopCount: this.loopCount,
-                    maxLoops: this.maxLoops
-                })];
-        }
-        catch (error) {
-            console.error('Error in LoopDetectionProcessor:', error);
-            return [this.createEvent('LoopDetectionError', {
-                    error: error instanceof Error ? error.message : String(error)
-                })];
-        }
-    }
-    generatePromptId() {
-        return `prompt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
-    async resetLoopDetector(promptId) {
-        this.loopCount = 0;
-        this.setContext('currentPromptId', promptId);
-        this.setContext('loopDetectorReset', Date.now().toString());
-        // Update CodeBolt agent state
-        try {
-            await codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', promptId);
-            await codeboltjs_1.default.cbstate.addToAgentState('loopDetectorReset', Date.now().toString());
-        }
-        catch (error) {
-            console.warn('Failed to update CodeBolt agent state:', error);
-        }
-    }
-    async checkLoopDetection() {
-        var _a;
-        try {
-            // Get recent messages from CodeBolt state
-            const agentState = await codeboltjs_1.default.cbstate.getAgentState();
-            const recentMessages = ((_a = agentState.data) === null || _a === void 0 ? void 0 : _a.recentMessages) || [];
-            // Simple loop detection: check for repeated patterns
-            if (recentMessages.length >= this.messageThreshold) {
-                const lastThree = recentMessages.slice(-3);
-                const previousThree = recentMessages.slice(-6, -3);
-                if (lastThree.length === 3 && previousThree.length === 3) {
-                    const isLoop = JSON.stringify(lastThree) === JSON.stringify(previousThree);
-                    if (isLoop) {
-                        console.log('[Loop Detection] Loop detected in conversation');
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-        catch (error) {
-            console.warn('Failed to check loop detection:', error);
-            return false;
-        }
-    }
-    // Public methods for external control
-    resetSession() {
-        this.loopCount = 0;
-        this.lastPromptId = null;
-        this.clearContext();
-        // Clear CodeBolt agent state
-        try {
-            codeboltjs_1.default.cbstate.addToAgentState('sessionTurnCount', '0');
-            codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', '');
-        }
-        catch (error) {
-            console.warn('Failed to clear CodeBolt agent state:', error);
-        }
-    }
-    getCurrentLoopCount() {
-        return this.loopCount;
-    }
-    setMaxLoops(maxLoops) {
-        this.maxLoops = Math.max(1, maxLoops);
-    }
-    enableLoopDetectionForSession() {
-        this.enableLoopDetection = true;
-    }
-    disableLoopDetectionForSession() {
-        this.enableLoopDetection = false;
-    }
-}
-exports.LoopDetectionProcessor = LoopDetectionProcessor;

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

@@ -1,30 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ResponseValidationProcessorOptions {
-    validateToolCalls?: boolean;
-    validateContent?: boolean;
-    validateStructure?: boolean;
-    allowEmptyContent?: boolean;
-    maxContentLength?: number;
-    requiredFields?: string[];
-}
-export interface ValidationResult {
-    isValid: boolean;
-    errors: string[];
-    warnings: string[];
-    fixes: string[];
-}
-export declare class ResponseValidationProcessor extends BaseProcessor {
-    private readonly enableToolCallValidation;
-    private readonly validateContent;
-    private readonly validateStructure;
-    private readonly allowEmptyContent;
-    private readonly maxContentLength;
-    private readonly requiredFields;
-    constructor(options?: ResponseValidationProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private validateMessage;
-    private validateMessageStructure;
-    private validateMessageContent;
-    private validateToolCallsInMessage;
-    getValidationSummary(validationResult: ValidationResult): string;
-}

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

@@ -1,228 +0,0 @@
-"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/postToolCall/telemetryProcessor.d.ts

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