@codebolt/agent 2.2.2 → 2.2.3

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

@@ -0,0 +1,291 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompactorProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const { chatSummary } = codeboltjs_1.default;
+/**
+ * Processor that compacts long conversations to keep them within manageable limits
+ * while preserving important context and recent interactions.
+ */
+class ConversationCompactorProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.maxConversationLength = options.maxConversationLength || 50;
+        this.compactionThreshold = options.compactionThreshold || 0.8; // Compact when 80% of max length
+        this.preserveRecentMessages = options.preserveRecentMessages || 10;
+        this.preserveSystemMessages = options.preserveSystemMessages !== false;
+        this.preserveToolMessages = options.preserveToolMessages !== false;
+        this.enableSummarization = options.enableSummarization !== false;
+        this.enableSmartRemoval = options.enableSmartRemoval !== false;
+        this.compressionRatio = options.compressionRatio || 0.6; // Target 60% of original size
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            const conversationLength = message.messages.length;
+            const threshold = Math.floor(this.maxConversationLength * this.compactionThreshold);
+            // Check if compaction is needed
+            if (conversationLength <= threshold) {
+                return [this.createEvent('ConversationCompactionSkipped', {
+                        conversationLength,
+                        threshold,
+                        reason: 'Below compaction threshold'
+                    })];
+            }
+            // Perform compaction
+            const compactedMessage = await this.compactConversation(message, context);
+            const compactionInfo = this.calculateCompactionInfo(message, compactedMessage);
+            return [
+                this.createEvent('ConversationCompacted', compactionInfo),
+                this.createEvent('ConversationProcessed', compactedMessage)
+            ];
+        }
+        catch (error) {
+            console.error('Error in ConversationCompactorProcessor:', error);
+            return [this.createEvent('ConversationCompactionError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    originalLength: input.message.messages.length
+                })];
+        }
+    }
+    async compactConversation(message, context) {
+        const messages = [...message.messages];
+        let compactionMethod = 'truncation';
+        // Try smart removal first if enabled
+        if (this.enableSmartRemoval) {
+            const smartCompacted = await this.performSmartRemoval(messages);
+            if (smartCompacted.length <= this.maxConversationLength) {
+                compactionMethod = 'smart_removal';
+                return {
+                    ...message,
+                    messages: smartCompacted,
+                    metadata: {
+                        ...message.metadata,
+                        compacted: true,
+                        compactionMethod,
+                        originalLength: messages.length,
+                        compactedLength: smartCompacted.length
+                    }
+                };
+            }
+        }
+        // Try summarization if enabled and we have chat summary service
+        if (this.enableSummarization) {
+            try {
+                const summarized = await this.performSummarization(messages);
+                if (summarized.length <= this.maxConversationLength) {
+                    compactionMethod = 'summarization';
+                    return {
+                        ...message,
+                        messages: summarized,
+                        metadata: {
+                            ...message.metadata,
+                            compacted: true,
+                            compactionMethod,
+                            originalLength: messages.length,
+                            compactedLength: summarized.length
+                        }
+                    };
+                }
+            }
+            catch (error) {
+                console.warn('Summarization failed, falling back to truncation:', error);
+            }
+        }
+        // Fall back to truncation
+        const truncated = this.performTruncation(messages);
+        return {
+            ...message,
+            messages: truncated,
+            metadata: {
+                ...message.metadata,
+                compacted: true,
+                compactionMethod,
+                originalLength: messages.length,
+                compactedLength: truncated.length
+            }
+        };
+    }
+    async performSmartRemoval(messages) {
+        const result = [];
+        const messagesToAnalyze = [...messages];
+        // Always preserve system messages if enabled
+        if (this.preserveSystemMessages) {
+            const systemMessages = messagesToAnalyze.filter(m => m.role === 'system');
+            result.push(...systemMessages);
+            messagesToAnalyze.splice(0, messagesToAnalyze.length, ...messagesToAnalyze.filter(m => m.role !== 'system'));
+        }
+        // Always preserve recent messages
+        const recentMessages = messagesToAnalyze.slice(-this.preserveRecentMessages);
+        const olderMessages = messagesToAnalyze.slice(0, -this.preserveRecentMessages);
+        // Analyze older messages for importance
+        const importantOlderMessages = this.selectImportantMessages(olderMessages);
+        // Preserve tool messages if enabled
+        let toolMessages = [];
+        if (this.preserveToolMessages) {
+            toolMessages = olderMessages.filter(m => m.role === 'tool');
+        }
+        // Combine all preserved messages
+        const preservedMessages = [
+            ...importantOlderMessages,
+            ...toolMessages,
+            ...recentMessages
+        ];
+        // Remove duplicates while preserving order
+        const seen = new Set();
+        const uniqueMessages = preservedMessages.filter(msg => {
+            const key = `${msg.role}-${JSON.stringify(msg.content)}-${msg.tool_call_id || ''}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        result.push(...uniqueMessages);
+        return result;
+    }
+    selectImportantMessages(messages) {
+        // Score messages based on importance criteria
+        const scoredMessages = messages.map(msg => ({
+            message: msg,
+            score: this.calculateMessageImportance(msg)
+        }));
+        // Sort by score (highest first)
+        scoredMessages.sort((a, b) => b.score - a.score);
+        // Select top messages up to compression ratio
+        const targetCount = Math.floor(messages.length * this.compressionRatio);
+        return scoredMessages.slice(0, targetCount).map(sm => sm.message);
+    }
+    calculateMessageImportance(message) {
+        let score = 0;
+        // Base score by role
+        switch (message.role) {
+            case 'system':
+                score += 10;
+                break;
+            case 'tool':
+                score += 8;
+                break;
+            case 'assistant':
+                score += 5;
+                break;
+            case 'user':
+                score += 3;
+                break;
+        }
+        // Content-based scoring
+        const content = typeof message.content === 'string'
+            ? message.content
+            : JSON.stringify(message.content);
+        // Longer messages might be more important
+        score += Math.min(content.length / 100, 5);
+        // Messages with tool calls are important
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            score += 7;
+        }
+        // Messages with specific keywords are important
+        const importantKeywords = [
+            'error', 'warning', 'critical', 'important', 'required',
+            'configuration', 'setup', 'install', 'deploy', 'build'
+        ];
+        const lowerContent = content.toLowerCase();
+        importantKeywords.forEach(keyword => {
+            if (lowerContent.includes(keyword)) {
+                score += 2;
+            }
+        });
+        return score;
+    }
+    async performSummarization(messages) {
+        try {
+            // Preserve system messages and recent messages
+            const systemMessages = this.preserveSystemMessages
+                ? messages.filter(m => m.role === 'system')
+                : [];
+            const recentMessages = messages.slice(-this.preserveRecentMessages);
+            const messagesToSummarize = messages.slice(0, -this.preserveRecentMessages)
+                .filter(m => !this.preserveSystemMessages || m.role !== 'system');
+            if (messagesToSummarize.length === 0) {
+                return [...systemMessages, ...recentMessages];
+            }
+            // Convert to format expected by chatSummary
+            const formattedMessages = messagesToSummarize.map(msg => ({
+                role: msg.role,
+                content: typeof msg.content === 'string' ? msg.content :
+                    Array.isArray(msg.content) ? msg.content.map(c => c.text).join(' ') :
+                        JSON.stringify(msg.content)
+            }));
+            // Use chat summary service
+            const targetLength = Math.floor(this.maxConversationLength * this.compressionRatio);
+            const summaryResponse = await chatSummary.summarize(formattedMessages, targetLength);
+            if (summaryResponse && (summaryResponse.payload || summaryResponse.summary)) {
+                const summaryText = summaryResponse.payload || summaryResponse.summary;
+                const summaryMessage = {
+                    role: 'system',
+                    content: `Previous conversation summary: ${summaryText}`,
+                    name: 'conversation-summary'
+                };
+                return [
+                    ...systemMessages,
+                    summaryMessage,
+                    ...recentMessages
+                ];
+            }
+            // If summarization fails, fall back to truncation
+            return this.performTruncation(messages);
+        }
+        catch (error) {
+            console.warn('Summarization failed:', error);
+            return this.performTruncation(messages);
+        }
+    }
+    performTruncation(messages) {
+        // Simple truncation: keep system messages + recent messages
+        const systemMessages = this.preserveSystemMessages
+            ? messages.filter(m => m.role === 'system')
+            : [];
+        const nonSystemMessages = messages.filter(m => !this.preserveSystemMessages || m.role !== 'system');
+        const availableSlots = this.maxConversationLength - systemMessages.length;
+        const recentMessages = nonSystemMessages.slice(-Math.max(availableSlots, this.preserveRecentMessages));
+        return [...systemMessages, ...recentMessages];
+    }
+    calculateCompactionInfo(original, compacted) {
+        var _a;
+        const originalCount = original.messages.length;
+        const compactedCount = compacted.messages.length;
+        return {
+            originalMessageCount: originalCount,
+            compactedMessageCount: compactedCount,
+            compressionRatio: compactedCount / originalCount,
+            compactionMethod: ((_a = compacted.metadata) === null || _a === void 0 ? void 0 : _a.compactionMethod) || 'truncation',
+            preservedMessages: compactedCount,
+            removedMessages: originalCount - compactedCount
+        };
+    }
+    // Public methods for configuration
+    setMaxConversationLength(length) {
+        this.maxConversationLength = Math.max(10, length);
+    }
+    setCompressionRatio(ratio) {
+        this.compressionRatio = Math.max(0.1, Math.min(0.9, ratio));
+    }
+    setPreserveRecentMessages(count) {
+        this.preserveRecentMessages = Math.max(1, count);
+    }
+    enableSummarizationForSession() {
+        this.enableSummarization = true;
+    }
+    disableSummarizationForSession() {
+        this.enableSummarization = false;
+    }
+    enableSmartRemovalForSession() {
+        this.enableSmartRemoval = true;
+    }
+    disableSmartRemovalForSession() {
+        this.enableSmartRemoval = false;
+    }
+}
+exports.ConversationCompactorProcessor = ConversationCompactorProcessor;

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

@@ -0,0 +1,49 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ConversationContinuityInfo {
+    contextLinksAdded: number;
+    referenceResolutionsAdded: number;
+    continuityEnhanced: boolean;
+    missingContextDetected: boolean;
+    conversationGapsFound: number;
+}
+export interface ConversationContinuityProcessorOptions {
+    enableContextLinking?: boolean;
+    enableReferenceResolution?: boolean;
+    enableGapDetection?: boolean;
+    maxContextLinks?: number;
+    contextLookbackWindow?: number;
+    enableProactiveContext?: boolean;
+}
+/**
+ * Processor that maintains conversation continuity by linking related messages,
+ * resolving references, and detecting context gaps in follow-up conversations.
+ */
+export declare class ConversationContinuityProcessor extends BaseProcessor {
+    private readonly enableContextLinking;
+    private readonly enableReferenceResolution;
+    private readonly enableGapDetection;
+    private readonly maxContextLinks;
+    private readonly contextLookbackWindow;
+    private readonly enableProactiveContext;
+    constructor(options?: ConversationContinuityProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private enhanceConversationContinuity;
+    private addContextLinks;
+    private findReferencingMessages;
+    private generateContextLinkMessage;
+    private resolveReferences;
+    private resolveMessageReferences;
+    private detectAndFillGaps;
+    private detectConversationGaps;
+    private generateGapFillerMessage;
+    private addProactiveContext;
+    private calculateContinuityInfo;
+    setContextLookbackWindow(window: number): void;
+    setMaxContextLinks(max: number): void;
+    enableContextLinkingForSession(): void;
+    disableContextLinkingForSession(): void;
+    enableReferenceResolutionForSession(): void;
+    disableReferenceResolutionForSession(): void;
+    enableGapDetectionForSession(): void;
+    disableGapDetectionForSession(): void;
+}

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

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

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