@codebolt/agent 5.0.2 → 5.0.6

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

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationContinuityProcessor = void 0;
-const processor_1 = require("../../processor");
-/**
- * Processor that maintains conversation continuity by linking related messages,
- * resolving references, and detecting context gaps in follow-up conversations.
- */
-class ConversationContinuityProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.enableContextLinking = options.enableContextLinking !== false;
-        this.enableReferenceResolution = options.enableReferenceResolution !== false;
-        this.enableGapDetection = options.enableGapDetection !== false;
-        this.maxContextLinks = options.maxContextLinks || 5;
-        this.contextLookbackWindow = options.contextLookbackWindow || 20;
-        this.enableProactiveContext = options.enableProactiveContext !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            // Only process follow-up conversations
-            if (!(context === null || context === void 0 ? void 0 : context.followUpProcessing)) {
-                return [this.createEvent('ContinuityProcessingSkipped', {
-                        reason: 'Not a follow-up conversation processing context'
-                    })];
-            }
-            const enhancedMessage = await this.enhanceConversationContinuity(message, context);
-            const continuityInfo = this.calculateContinuityInfo(message, enhancedMessage, context);
-            return [
-                this.createEvent('ConversationContinuityProcessed', continuityInfo),
-                this.createEvent('ConversationProcessed', enhancedMessage)
-            ];
-        }
-        catch (error) {
-            console.error('Error in ConversationContinuityProcessor:', error);
-            return [this.createEvent('ConversationContinuityError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    originalLength: input.message.messages.length
-                })];
-        }
-    }
-    async enhanceConversationContinuity(message, context) {
-        let enhancedMessages = [...message.messages];
-        let enhancementsAdded = 0;
-        // Add context links if enabled
-        if (this.enableContextLinking) {
-            const contextLinks = this.addContextLinks(enhancedMessages, context);
-            enhancedMessages.push(...contextLinks);
-            enhancementsAdded += contextLinks.length;
-        }
-        // Resolve references if enabled
-        if (this.enableReferenceResolution) {
-            enhancedMessages = this.resolveReferences(enhancedMessages, context);
-        }
-        // Detect and fill conversation gaps if enabled
-        if (this.enableGapDetection) {
-            const gapFillers = this.detectAndFillGaps(enhancedMessages, context);
-            enhancedMessages.push(...gapFillers);
-            enhancementsAdded += gapFillers.length;
-        }
-        // Add proactive context if enabled
-        if (this.enableProactiveContext) {
-            const proactiveContext = this.addProactiveContext(enhancedMessages, context);
-            enhancedMessages.push(...proactiveContext);
-            enhancementsAdded += proactiveContext.length;
-        }
-        return {
-            ...message,
-            messages: enhancedMessages,
-            metadata: {
-                ...message.metadata,
-                continuityEnhanced: true,
-                enhancementsAdded,
-                timestamp: new Date().toISOString()
-            }
-        };
-    }
-    addContextLinks(messages, context) {
-        const contextLinks = [];
-        const recentMessages = messages.slice(-this.contextLookbackWindow);
-        // Find messages that reference previous interactions
-        const referencingMessages = this.findReferencingMessages(recentMessages);
-        if (referencingMessages.length > 0) {
-            const linkMessage = {
-                role: 'system',
-                content: this.generateContextLinkMessage(referencingMessages, context),
-                name: 'context-link'
-            };
-            contextLinks.push(linkMessage);
-        }
-        return contextLinks.slice(0, this.maxContextLinks);
-    }
-    findReferencingMessages(messages) {
-        const referencePatterns = [
-            /\b(this|that|it|they|them)\b/i,
-            /\b(the (above|previous|last|earlier))\b/i,
-            /\b(as (mentioned|discussed|shown))\b/i,
-            /\b(from (before|earlier))\b/i,
-            /\b(the (file|code|result|output))\b/i
-        ];
-        return messages.filter(message => {
-            const content = typeof message.content === 'string'
-                ? message.content
-                : JSON.stringify(message.content);
-            return referencePatterns.some(pattern => pattern.test(content));
-        });
-    }
-    generateContextLinkMessage(referencingMessages, context) {
-        const messageCount = referencingMessages.length;
-        const toolResults = context.toolResults || [];
-        let linkMessage = `**Context Links:** Found ${messageCount} message${messageCount > 1 ? 's' : ''} with references to previous interactions.`;
-        if (toolResults.length > 0) {
-            linkMessage += ` Recent tool executions: ${toolResults.length} tool${toolResults.length > 1 ? 's' : ''} executed.`;
-        }
-        if (context.originalHistory && context.originalHistory.length > 0) {
-            linkMessage += ` Conversation history: ${context.originalHistory.length} previous messages available for reference.`;
-        }
-        return linkMessage;
-    }
-    resolveReferences(messages, context) {
-        return messages.map(message => {
-            if (message.role === 'system' || message.name === 'reference-resolution') {
-                return message;
-            }
-            const resolvedContent = this.resolveMessageReferences(message.content, context);
-            if (resolvedContent !== message.content) {
-                return {
-                    ...message,
-                    content: resolvedContent,
-                    name: message.name || 'reference-resolved'
-                };
-            }
-            return message;
-        });
-    }
-    resolveMessageReferences(content, context) {
-        if (typeof content !== 'string') {
-            return content;
-        }
-        let resolvedContent = content;
-        const toolResults = context.toolResults || [];
-        // Resolve "the file" references
-        if (/\bthe file\b/i.test(resolvedContent) && toolResults.length > 0) {
-            const fileOperations = toolResults.filter((result) => result.tool_call_id && result.tool_call_id.includes('file'));
-            if (fileOperations.length === 1) {
-                resolvedContent = resolvedContent.replace(/\bthe file\b/gi, `the file (from recent tool execution)`);
-            }
-        }
-        // Resolve "the result" references
-        if (/\bthe result\b/i.test(resolvedContent) && toolResults.length > 0) {
-            resolvedContent = resolvedContent.replace(/\bthe result\b/gi, `the result (from ${toolResults.length} recent tool execution${toolResults.length > 1 ? 's' : ''})`);
-        }
-        // Resolve "it" references in context of tool operations
-        if (/\bit\b/i.test(resolvedContent) && toolResults.length === 1) {
-            const toolResult = toolResults[0];
-            if (toolResult.tool_call_id) {
-                resolvedContent = resolvedContent.replace(/\bit\b/gi, `it (referring to the tool execution result)`);
-            }
-        }
-        return resolvedContent;
-    }
-    detectAndFillGaps(messages, context) {
-        const gapFillers = [];
-        const gaps = this.detectConversationGaps(messages, context);
-        gaps.forEach(gap => {
-            const fillerMessage = {
-                role: 'system',
-                content: this.generateGapFillerMessage(gap, context),
-                name: 'gap-filler'
-            };
-            gapFillers.push(fillerMessage);
-        });
-        return gapFillers;
-    }
-    detectConversationGaps(messages, context) {
-        const gaps = [];
-        const toolResults = context.toolResults || [];
-        // Gap: Tool results without explanation
-        const unexplainedToolResults = toolResults.filter((result) => {
-            const hasExplanation = messages.some(msg => msg.role === 'assistant' &&
-                typeof msg.content === 'string' &&
-                msg.content.includes('result'));
-            return !hasExplanation;
-        });
-        if (unexplainedToolResults.length > 0) {
-            gaps.push({
-                type: 'unexplained-tool-results',
-                description: `${unexplainedToolResults.length} tool result(s) without explanation`,
-                severity: 'medium'
-            });
-        }
-        // Gap: Missing context for references
-        const unresolvedReferences = messages.filter(msg => {
-            const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
-            return /\b(this|that|it)\b/i.test(content) && msg.role === 'user';
-        });
-        if (unresolvedReferences.length > 2) {
-            gaps.push({
-                type: 'unresolved-references',
-                description: `${unresolvedReferences.length} messages with unclear references`,
-                severity: 'low'
-            });
-        }
-        // Gap: Long silence after tool execution
-        const lastToolIndex = messages.findLastIndex(msg => msg.role === 'tool');
-        const lastAssistantIndex = messages.findLastIndex(msg => msg.role === 'assistant');
-        if (lastToolIndex > lastAssistantIndex && lastToolIndex < messages.length - 1) {
-            gaps.push({
-                type: 'missing-tool-response',
-                description: 'Tool execution without assistant response',
-                severity: 'high'
-            });
-        }
-        return gaps;
-    }
-    generateGapFillerMessage(gap, context) {
-        switch (gap.type) {
-            case 'unexplained-tool-results':
-                return `**Context Note:** There are tool execution results that may need explanation or analysis. Consider reviewing the tool outputs and their implications.`;
-            case 'unresolved-references':
-                return `**Context Note:** Some messages contain references that might be unclear. Consider providing more specific context when referring to previous interactions.`;
-            case 'missing-tool-response':
-                return `**Context Note:** Recent tool execution completed but may need assistant analysis or response to continue the conversation effectively.`;
-            default:
-                return `**Context Note:** Potential conversation gap detected: ${gap.description}`;
-        }
-    }
-    addProactiveContext(messages, context) {
-        const proactiveMessages = [];
-        const toolResults = context.toolResults || [];
-        const conversationLength = messages.length;
-        // Add proactive context for complex tool interactions
-        if (toolResults.length > 3) {
-            proactiveMessages.push({
-                role: 'system',
-                content: `**Proactive Context:** Multiple tools have been executed (${toolResults.length} total). This suggests a complex task that may benefit from step-by-step progress tracking.`,
-                name: 'proactive-context'
-            });
-        }
-        // Add proactive context for long conversations
-        if (conversationLength > 25) {
-            proactiveMessages.push({
-                role: 'system',
-                content: `**Proactive Context:** This is an extended conversation (${conversationLength} messages). Consider summarizing progress or breaking down remaining objectives.`,
-                name: 'proactive-context'
-            });
-        }
-        return proactiveMessages.slice(0, 2); // Limit proactive messages
-    }
-    calculateContinuityInfo(original, enhanced, context) {
-        const originalCount = original.messages.length;
-        const enhancedCount = enhanced.messages.length;
-        const addedMessages = enhancedCount - originalCount;
-        // Count different types of enhancements
-        const contextLinks = enhanced.messages.filter(m => m.name === 'context-link').length;
-        const referenceResolutions = enhanced.messages.filter(m => m.name === 'reference-resolved').length;
-        const gapFillers = enhanced.messages.filter(m => m.name === 'gap-filler').length;
-        return {
-            contextLinksAdded: contextLinks,
-            referenceResolutionsAdded: referenceResolutions,
-            continuityEnhanced: addedMessages > 0,
-            missingContextDetected: gapFillers > 0,
-            conversationGapsFound: gapFillers
-        };
-    }
-    // Public methods for configuration
-    setContextLookbackWindow(window) {
-        this.contextLookbackWindow = Math.max(5, Math.min(50, window));
-    }
-    setMaxContextLinks(max) {
-        this.maxContextLinks = Math.max(1, Math.min(10, max));
-    }
-    enableContextLinkingForSession() {
-        this.enableContextLinking = true;
-    }
-    disableContextLinkingForSession() {
-        this.enableContextLinking = false;
-    }
-    enableReferenceResolutionForSession() {
-        this.enableReferenceResolution = true;
-    }
-    disableReferenceResolutionForSession() {
-        this.enableReferenceResolution = false;
-    }
-    enableGapDetectionForSession() {
-        this.enableGapDetection = true;
-    }
-    disableGapDetectionForSession() {
-        this.enableGapDetection = false;
-    }
-}
-exports.ConversationContinuityProcessor = ConversationContinuityProcessor;

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

@@ -1,47 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface FollowUpConversationInfo {
-    toolResultsProcessed: number;
-    followUpMessagesAdded: number;
-    conversationEnhanced: boolean;
-    processingMethod: 'automatic' | 'guided' | 'minimal';
-}
-export interface FollowUpConversationProcessorOptions {
-    addFollowUpPrompts?: boolean;
-    enhanceToolResults?: boolean;
-    addContextualHints?: boolean;
-    processingMode?: 'automatic' | 'guided' | 'minimal';
-    maxFollowUpMessages?: number;
-    enableToolResultEnhancement?: boolean;
-    enableConversationGuidance?: boolean;
-}
-/**
- * Processor that enhances follow-up conversations by adding contextual information,
- * improving tool result presentation, and providing guidance for continued interaction.
- */
-export declare class FollowUpConversationProcessor extends BaseProcessor {
-    private readonly addFollowUpPrompts;
-    private readonly enhanceToolResults;
-    private readonly addContextualHints;
-    private readonly processingMode;
-    private readonly maxFollowUpMessages;
-    private readonly enableToolResultEnhancement;
-    private readonly enableConversationGuidance;
-    constructor(options?: FollowUpConversationProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private enhanceFollowUpConversation;
-    private enhanceToolResultMessages;
-    private enhanceToolResultContent;
-    private generateFollowUpPrompts;
-    private generateGuidedPrompts;
-    private generateAutomaticPrompts;
-    private generateContextualHints;
-    private calculateProcessingInfo;
-    setProcessingMode(mode: 'automatic' | 'guided' | 'minimal'): void;
-    setMaxFollowUpMessages(count: number): void;
-    enableFollowUpPromptsForSession(): void;
-    disableFollowUpPromptsForSession(): void;
-    enableToolResultEnhancementForSession(): void;
-    disableToolResultEnhancementForSession(): void;
-    enableConversationGuidanceForSession(): void;
-    disableConversationGuidanceForSession(): void;
-}

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

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FollowUpConversationProcessor = void 0;
-const processor_1 = require("../../processor");
-/**
- * Processor that enhances follow-up conversations by adding contextual information,
- * improving tool result presentation, and providing guidance for continued interaction.
- */
-class FollowUpConversationProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.addFollowUpPrompts = options.addFollowUpPrompts !== false;
-        this.enhanceToolResults = options.enhanceToolResults !== false;
-        this.addContextualHints = options.addContextualHints !== false;
-        this.processingMode = options.processingMode || 'automatic';
-        this.maxFollowUpMessages = options.maxFollowUpMessages || 3;
-        this.enableToolResultEnhancement = options.enableToolResultEnhancement !== false;
-        this.enableConversationGuidance = options.enableConversationGuidance !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            // Check if this is a follow-up conversation processing
-            if (!(context === null || context === void 0 ? void 0 : context.followUpProcessing)) {
-                return [this.createEvent('FollowUpProcessingSkipped', {
-                        reason: 'Not a follow-up conversation processing context'
-                    })];
-            }
-            const enhancedMessage = await this.enhanceFollowUpConversation(message, context);
-            const processingInfo = this.calculateProcessingInfo(message, enhancedMessage, context);
-            return [
-                this.createEvent('FollowUpConversationProcessed', processingInfo),
-                this.createEvent('ConversationProcessed', enhancedMessage)
-            ];
-        }
-        catch (error) {
-            console.error('Error in FollowUpConversationProcessor:', error);
-            return [this.createEvent('FollowUpConversationError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    originalLength: input.message.messages.length
-                })];
-        }
-    }
-    async enhanceFollowUpConversation(message, context) {
-        let enhancedMessages = [...message.messages];
-        let enhancementsAdded = 0;
-        // Enhance tool results if enabled
-        if (this.enableToolResultEnhancement && this.enhanceToolResults) {
-            enhancedMessages = this.enhanceToolResultMessages(enhancedMessages, context);
-            enhancementsAdded++;
-        }
-        // Add follow-up prompts if enabled
-        if (this.addFollowUpPrompts && this.processingMode !== 'minimal') {
-            const followUpMessages = this.generateFollowUpPrompts(enhancedMessages, context);
-            enhancedMessages.push(...followUpMessages);
-            enhancementsAdded += followUpMessages.length;
-        }
-        // Add contextual hints if enabled
-        if (this.addContextualHints && this.enableConversationGuidance) {
-            const contextualMessages = this.generateContextualHints(enhancedMessages, context);
-            enhancedMessages.push(...contextualMessages);
-            enhancementsAdded += contextualMessages.length;
-        }
-        return {
-            ...message,
-            messages: enhancedMessages,
-            metadata: {
-                ...message.metadata,
-                followUpEnhanced: true,
-                enhancementsAdded,
-                processingMode: this.processingMode,
-                timestamp: new Date().toISOString()
-            }
-        };
-    }
-    enhanceToolResultMessages(messages, context) {
-        return messages.map(message => {
-            if (message.role !== 'tool') {
-                return message;
-            }
-            // Enhance tool result presentation
-            const enhancedContent = this.enhanceToolResultContent(message.content, context);
-            return {
-                ...message,
-                content: enhancedContent,
-                name: message.name || 'tool-result'
-            };
-        });
-    }
-    enhanceToolResultContent(content, context) {
-        if (typeof content !== 'string') {
-            return content;
-        }
-        // Add formatting and context to tool results
-        let enhancedContent = content;
-        // Add success/failure indicators
-        if (content.toLowerCase().includes('error') || content.toLowerCase().includes('failed')) {
-            enhancedContent = `❌ **Tool Execution Result:**\n${content}\n\n*The tool encountered an issue. Please review the error and try again if needed.*`;
-        }
-        else if (content.toLowerCase().includes('success') || content.toLowerCase().includes('completed')) {
-            enhancedContent = `✅ **Tool Execution Result:**\n${content}\n\n*The tool executed successfully.*`;
-        }
-        else {
-            enhancedContent = `🔧 **Tool Execution Result:**\n${content}`;
-        }
-        // Add tool execution context if available
-        if (context.toolResults && Array.isArray(context.toolResults)) {
-            const toolCount = context.toolResults.length;
-            if (toolCount > 1) {
-                enhancedContent += `\n\n*This is one of ${toolCount} tool results in this interaction.*`;
-            }
-        }
-        return enhancedContent;
-    }
-    generateFollowUpPrompts(messages, context) {
-        const followUpMessages = [];
-        const toolResults = context.toolResults || [];
-        const hasErrors = toolResults.some((result) => result.content && result.content.toLowerCase().includes('error'));
-        // Add different prompts based on processing mode
-        switch (this.processingMode) {
-            case 'guided':
-                followUpMessages.push(...this.generateGuidedPrompts(messages, context, hasErrors));
-                break;
-            case 'automatic':
-                followUpMessages.push(...this.generateAutomaticPrompts(messages, context, hasErrors));
-                break;
-            case 'minimal':
-                // Minimal mode doesn't add prompts
-                break;
-        }
-        // Limit the number of follow-up messages
-        return followUpMessages.slice(0, this.maxFollowUpMessages);
-    }
-    generateGuidedPrompts(messages, context, hasErrors) {
-        var _a;
-        const prompts = [];
-        if (hasErrors) {
-            prompts.push({
-                role: 'user',
-                content: "I notice there were some errors in the tool execution. Would you like me to:\n1. Retry the failed operations\n2. Try an alternative approach\n3. Provide more details about the errors\n4. Continue with the successful results\n\nPlease let me know how you'd like to proceed.",
-                name: 'error-guidance-prompt'
-            });
-        }
-        else {
-            const toolCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
-            if (toolCount > 0) {
-                prompts.push({
-                    role: 'user',
-                    content: `The tools have been executed successfully. Based on the results, would you like me to:\n1. Analyze the results further\n2. Perform additional related tasks\n3. Provide a summary of what was accomplished\n4. Continue with the next steps\n\nWhat would be most helpful?`,
-                    name: 'success-guidance-prompt'
-                });
-            }
-        }
-        return prompts;
-    }
-    generateAutomaticPrompts(messages, context, hasErrors) {
-        var _a;
-        const prompts = [];
-        if (hasErrors) {
-            prompts.push({
-                role: 'user',
-                content: "Please review the errors above and suggest how to resolve them or continue with alternative approaches.",
-                name: 'automatic-error-prompt'
-            });
-        }
-        else {
-            const toolCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
-            if (toolCount > 0) {
-                prompts.push({
-                    role: 'user',
-                    content: "Please analyze the tool execution results and let me know if there are any next steps or if the task has been completed successfully.",
-                    name: 'automatic-success-prompt'
-                });
-            }
-        }
-        return prompts;
-    }
-    generateContextualHints(messages, context) {
-        const hints = [];
-        const toolResults = context.toolResults || [];
-        const conversationLength = context.conversationLength || 0;
-        // Add hints based on conversation state
-        if (conversationLength > 30) {
-            hints.push({
-                role: 'system',
-                content: "Note: This conversation is getting quite long. Consider summarizing progress or breaking down remaining tasks into smaller steps.",
-                name: 'conversation-length-hint'
-            });
-        }
-        // Add hints based on tool execution patterns
-        if (toolResults.length > 5) {
-            hints.push({
-                role: 'system',
-                content: "Multiple tools have been executed in this interaction. Consider reviewing the overall progress and determining if the objectives have been met.",
-                name: 'tool-execution-hint'
-            });
-        }
-        // Add hints for specific tool types
-        const fileOperations = toolResults.filter((result) => result.tool_call_id && (result.tool_call_id.includes('file') ||
-            result.tool_call_id.includes('read') ||
-            result.tool_call_id.includes('write')));
-        if (fileOperations.length > 0) {
-            hints.push({
-                role: 'system',
-                content: "File operations have been performed. Consider verifying the changes and ensuring all modifications are correct.",
-                name: 'file-operations-hint'
-            });
-        }
-        return hints.slice(0, 2); // Limit hints to avoid clutter
-    }
-    calculateProcessingInfo(original, enhanced, context) {
-        var _a;
-        const originalCount = original.messages.length;
-        const enhancedCount = enhanced.messages.length;
-        const toolResultsCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
-        return {
-            toolResultsProcessed: toolResultsCount,
-            followUpMessagesAdded: enhancedCount - originalCount,
-            conversationEnhanced: enhancedCount > originalCount,
-            processingMethod: this.processingMode
-        };
-    }
-    // Public methods for configuration
-    setProcessingMode(mode) {
-        this.processingMode = mode;
-    }
-    setMaxFollowUpMessages(count) {
-        this.maxFollowUpMessages = Math.max(0, Math.min(10, count));
-    }
-    enableFollowUpPromptsForSession() {
-        this.addFollowUpPrompts = true;
-    }
-    disableFollowUpPromptsForSession() {
-        this.addFollowUpPrompts = false;
-    }
-    enableToolResultEnhancementForSession() {
-        this.enableToolResultEnhancement = true;
-    }
-    disableToolResultEnhancementForSession() {
-        this.enableToolResultEnhancement = false;
-    }
-    enableConversationGuidanceForSession() {
-        this.enableConversationGuidance = true;
-    }
-    disableConversationGuidanceForSession() {
-        this.enableConversationGuidance = false;
-    }
-}
-exports.FollowUpConversationProcessor = FollowUpConversationProcessor;

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

@@ -1,30 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface LoopDetectionInfo {
-    promptId: string;
-    loopCount: number;
-    maxLoops: number;
-    recentMessages: any[];
-    isLoop: boolean;
-}
-export interface LoopDetectionProcessorOptions {
-    maxLoops?: number;
-    messageThreshold?: number;
-    enableLoopDetection?: boolean;
-}
-export declare class LoopDetectionProcessor extends BaseProcessor {
-    private readonly maxLoops;
-    private readonly messageThreshold;
-    private readonly enableLoopDetection;
-    private lastPromptId;
-    private loopCount;
-    constructor(options?: LoopDetectionProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private generatePromptId;
-    private resetLoopDetector;
-    private checkLoopDetection;
-    resetSession(): void;
-    getCurrentLoopCount(): number;
-    setMaxLoops(maxLoops: number): void;
-    enableLoopDetectionForSession(): void;
-    disableLoopDetectionForSession(): void;
-}