@codebolt/agent 5.0.8 → 6.0.0

package/dist/processor-pieces/messageModifiers/workingDirectoryMessageModifier.js

@@ -1,194 +0,0 @@
-"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;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkingDirectoryMessageModifier = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-const path = __importStar(require("path"));
-class WorkingDirectoryMessageModifier extends processor_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super({ context: options });
-        this.showFolderStructureSummary = options.showFolderStructureSummary || false;
-        this.listFiles = options.listFiles || false;
-        this.listFilesDepth = options.listFilesDepth || 2;
-        this.listFilesLimit = options.listFilesLimit || 200;
-        this.listFilesIgnoreFromGitignore = options.listFilesIgnoreFromGitignore || true;
-        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', 'build'];
-    }
-    async modify(input) {
-        try {
-            const { originalRequest, createdMessage, context } = input;
-            const contextParts = [];
-            // Get project information
-            try {
-                const projectPathResponse = await codeboltjs_1.default.project.getProjectPath();
-                const projectPath = typeof projectPathResponse === 'string'
-                    ? projectPathResponse
-                    : (projectPathResponse === null || projectPathResponse === void 0 ? void 0 : projectPathResponse.path) || String(projectPathResponse) || '';
-                contextParts.push(`Project Directory: ${projectPath}`);
-                if (this.showFolderStructureSummary) {
-                    const summary = await this.generateFolderStructureSummary(projectPath);
-                    contextParts.push(`Folder Structure Summary:\n${summary}`);
-                }
-                if (this.listFiles) {
-                    const filesList = await this.generateFilesList(projectPath);
-                    contextParts.push(`Files List:\n${filesList}`);
-                }
-            }
-            catch (error) {
-                console.error('Error getting project information:', error);
-                contextParts.push('Working Directory: Unable to access project information');
-            }
-            // Create context message if we have any context parts
-            if (contextParts.length > 0) {
-                const contextMessage = {
-                    role: 'system',
-                    content: contextParts.join('\n\n'),
-                    name: 'working-directory-context'
-                };
-                return {
-                    messages: [contextMessage, ...createdMessage.messages],
-                    metadata: {
-                        ...createdMessage.metadata,
-                        workingDirectoryContextAdded: true,
-                        contextParts: contextParts.length
-                    }
-                };
-            }
-            return createdMessage;
-        }
-        catch (error) {
-            console.error('Error in WorkingDirectoryMessageModifier:', error);
-            throw error;
-        }
-    }
-    async generateFolderStructureSummary(projectPath) {
-        try {
-            // Use CodeBolt's directory listing with recursive option
-            const response = await codeboltjs_1.default.fs.listDirectory({
-                path: projectPath,
-                show_hidden: false,
-                detailed: false,
-                limit: 200,
-                notifyUser: false
-            });
-            const directories = new Set();
-            // Extract directories from the response
-            if (response && response.success) {
-                let entries;
-                if (typeof response.result === 'string') {
-                    // If result is a string, we'll need to parse it or work with what we have
-                    return response.result.split('\n').slice(0, 20).join('\n');
-                }
-                else if (response.result && response.result.entries) {
-                    entries = response.result.entries;
-                }
-                else if (response.entries) {
-                    entries = response.entries;
-                }
-                if (entries) {
-                    entries.forEach((entry) => {
-                        if (entry.type === 'directory' && !this.shouldIgnore(entry.path || entry.name)) {
-                            directories.add(entry.path || entry.name);
-                        }
-                        // Also get parent directories of files
-                        const dir = path.dirname(entry.path || entry.name);
-                        if (dir !== '.' && !this.shouldIgnore(dir)) {
-                            directories.add(dir);
-                        }
-                    });
-                }
-            }
-            const sortedDirs = Array.from(directories).sort();
-            return sortedDirs.length > 0
-                ? sortedDirs.slice(0, 20).join('\n')
-                : 'No accessible directories found';
-        }
-        catch (error) {
-            return 'Unable to generate folder structure summary';
-        }
-    }
-    async generateFilesList(projectPath) {
-        try {
-            // Use CodeBolt's directory listing to get files
-            const response = await codeboltjs_1.default.fs.listDirectory({
-                path: projectPath,
-                show_hidden: false,
-                detailed: false,
-                limit: this.listFilesLimit,
-                notifyUser: false
-            });
-            const files = [];
-            // Extract files from the response
-            if (response && response.success) {
-                let entries;
-                if (typeof response.result === 'string') {
-                    // If result is a string, split and filter for files
-                    return response.result.split('\n')
-                        .filter((line) => !this.shouldIgnore(line))
-                        .slice(0, this.listFilesLimit)
-                        .join('\n');
-                }
-                else if (response.result && response.result.entries) {
-                    entries = response.result.entries;
-                }
-                else if (response.entries) {
-                    entries = response.entries;
-                }
-                if (entries) {
-                    entries.forEach((entry) => {
-                        if (entry.type === 'file' && !this.shouldIgnore(entry.path || entry.name)) {
-                            files.push(entry.path || entry.name);
-                        }
-                    });
-                }
-            }
-            const filteredFiles = files.slice(0, this.listFilesLimit);
-            return filteredFiles.length > 0
-                ? filteredFiles.join('\n')
-                : 'No accessible files found';
-        }
-        catch (error) {
-            return 'Unable to generate files list';
-        }
-    }
-    shouldIgnore(filePath) {
-        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || path.basename(filePath) === ignore);
-    }
-}
-exports.WorkingDirectoryMessageModifier = WorkingDirectoryMessageModifier;

package/dist/processor-pieces/processors/advancedLoopDetectionProcessor.d.ts

@@ -1,41 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface AdvancedLoopDetectionProcessorOptions {
-    toolCallThreshold?: number;
-    contentLoopThreshold?: number;
-    contentChunkSize?: number;
-    maxHistoryLength?: number;
-    enableLLMDetection?: boolean;
-    llmCheckAfterTurns?: number;
-    defaultLLMCheckInterval?: number;
-}
-export declare class AdvancedLoopDetectionProcessor extends BaseProcessor {
-    private readonly toolCallThreshold;
-    private readonly contentLoopThreshold;
-    private readonly contentChunkSize;
-    private readonly maxHistoryLength;
-    private readonly enableLLMDetection;
-    private readonly llmCheckAfterTurns;
-    private readonly defaultLLMCheckInterval;
-    private lastToolCallKey;
-    private toolCallRepetitionCount;
-    private streamContentHistory;
-    private contentStats;
-    private lastContentIndex;
-    private loopDetected;
-    private inCodeBlock;
-    private turnsInCurrentPrompt;
-    private llmCheckInterval;
-    private lastCheckTurn;
-    constructor(options?: AdvancedLoopDetectionProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private getToolCallKey;
-    private checkToolCallLoop;
-    private checkContentLoop;
-    private truncateAndUpdate;
-    private analyzeContentChunksForLoop;
-    private hasMoreChunksToProcess;
-    private isLoopDetectedForChunk;
-    private isActualContentMatch;
-    private resetContentTracking;
-    reset(): void;
-}

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

@@ -1,197 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdvancedLoopDetectionProcessor = void 0;
-const processor_1 = require("../../processor");
-const crypto_1 = require("crypto");
-class AdvancedLoopDetectionProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super();
-        // Tool call tracking
-        this.lastToolCallKey = null;
-        this.toolCallRepetitionCount = 0;
-        // Content streaming tracking
-        this.streamContentHistory = '';
-        this.contentStats = new Map();
-        this.lastContentIndex = 0;
-        this.loopDetected = false;
-        this.inCodeBlock = false;
-        // Turn tracking
-        this.turnsInCurrentPrompt = 0;
-        this.lastCheckTurn = 0;
-        this.toolCallThreshold = options.toolCallThreshold || 5;
-        this.contentLoopThreshold = options.contentLoopThreshold || 10;
-        this.contentChunkSize = options.contentChunkSize || 50;
-        this.maxHistoryLength = options.maxHistoryLength || 1000;
-        this.enableLLMDetection = options.enableLLMDetection || false;
-        this.llmCheckAfterTurns = options.llmCheckAfterTurns || 30;
-        this.defaultLLMCheckInterval = options.defaultLLMCheckInterval || 3;
-        this.llmCheckInterval = this.defaultLLMCheckInterval;
-    }
-    async processInput(input) {
-        const { message, context } = input;
-        // Increment turn counter
-        this.turnsInCurrentPrompt++;
-        // Check for tool call loops in the last message
-        const lastMessage = message.messages[message.messages.length - 1];
-        if (lastMessage.tool_calls && lastMessage.tool_calls.length > 0) {
-            for (const toolCall of lastMessage.tool_calls) {
-                const isLoop = this.checkToolCallLoop({
-                    name: toolCall.function.name,
-                    args: typeof toolCall.function.arguments === 'string'
-                        ? JSON.parse(toolCall.function.arguments)
-                        : toolCall.function.arguments
-                });
-                if (isLoop) {
-                    this.loopDetected = true;
-                    return [this.createEvent('LoopDetected', {
-                            type: 'tool_call_loop',
-                            toolCall: toolCall.function.name,
-                            repetitionCount: this.toolCallRepetitionCount,
-                            threshold: this.toolCallThreshold
-                        })];
-                }
-            }
-        }
-        // Check for content loops
-        if (lastMessage.content && typeof lastMessage.content === 'string') {
-            const isContentLoop = this.checkContentLoop(lastMessage.content);
-            if (isContentLoop) {
-                this.loopDetected = true;
-                return [this.createEvent('LoopDetected', {
-                        type: 'content_loop',
-                        contentLength: this.streamContentHistory.length,
-                        threshold: this.contentLoopThreshold
-                    })];
-            }
-        }
-        // LLM-based loop detection (if enabled)
-        if (this.enableLLMDetection &&
-            this.turnsInCurrentPrompt >= this.llmCheckAfterTurns &&
-            this.turnsInCurrentPrompt - this.lastCheckTurn >= this.llmCheckInterval) {
-            this.lastCheckTurn = this.turnsInCurrentPrompt;
-            // For now, just log that LLM check would happen
-            // In a real implementation, this would call an LLM to analyze the conversation
-            console.log('[AdvancedLoopDetection] LLM-based loop check would be performed here');
-        }
-        return [this.createEvent('LoopCheckCompleted', {
-                loopDetected: this.loopDetected,
-                turnsInPrompt: this.turnsInCurrentPrompt,
-                toolCallCount: this.toolCallRepetitionCount
-            })];
-    }
-    getToolCallKey(toolCall) {
-        const argsString = JSON.stringify(toolCall.args);
-        const keyString = `${toolCall.name}:${argsString}`;
-        return (0, crypto_1.createHash)('sha256').update(keyString).digest('hex');
-    }
-    checkToolCallLoop(toolCall) {
-        const key = this.getToolCallKey(toolCall);
-        if (this.lastToolCallKey === key) {
-            this.toolCallRepetitionCount++;
-        }
-        else {
-            this.lastToolCallKey = key;
-            this.toolCallRepetitionCount = 1;
-        }
-        return this.toolCallRepetitionCount >= this.toolCallThreshold;
-    }
-    checkContentLoop(content) {
-        var _a;
-        // Different content elements can often contain repetitive syntax that is not indicative of a loop.
-        // To avoid false positives, we detect when we encounter different content types and
-        // reset tracking to avoid analyzing content that spans across different element boundaries.
-        const numFences = ((_a = content.match(/```/g)) !== null && _a !== void 0 ? _a : []).length;
-        const hasTable = /(^|\n)\s*(\|.*\||[|+-]{3,})/.test(content);
-        const hasListItem = /(^|\n)\s*[*-+]\s/.test(content) || /(^|\n)\s*\d+\.\s/.test(content);
-        const hasHeading = /(^|\n)#+\s/.test(content);
-        const hasBlockquote = /(^|\n)>\s/.test(content);
-        if (numFences || hasTable || hasListItem || hasHeading || hasBlockquote) {
-            // Reset tracking when different content elements are detected
-            this.resetContentTracking();
-        }
-        const wasInCodeBlock = this.inCodeBlock;
-        this.inCodeBlock = numFences % 2 === 0 ? this.inCodeBlock : !this.inCodeBlock;
-        if (wasInCodeBlock || this.inCodeBlock) {
-            return false;
-        }
-        this.streamContentHistory += content;
-        this.truncateAndUpdate();
-        return this.analyzeContentChunksForLoop();
-    }
-    truncateAndUpdate() {
-        if (this.streamContentHistory.length <= this.maxHistoryLength) {
-            return;
-        }
-        const truncationAmount = this.streamContentHistory.length - this.maxHistoryLength;
-        this.streamContentHistory = this.streamContentHistory.slice(truncationAmount);
-        this.lastContentIndex = Math.max(0, this.lastContentIndex - truncationAmount);
-        // Update all stored chunk indices to account for the truncation
-        for (const [hash, oldIndices] of this.contentStats.entries()) {
-            const adjustedIndices = oldIndices
-                .map((index) => index - truncationAmount)
-                .filter((index) => index >= 0);
-            if (adjustedIndices.length > 0) {
-                this.contentStats.set(hash, adjustedIndices);
-            }
-            else {
-                this.contentStats.delete(hash);
-            }
-        }
-    }
-    analyzeContentChunksForLoop() {
-        while (this.hasMoreChunksToProcess()) {
-            const currentChunk = this.streamContentHistory.substring(this.lastContentIndex, this.lastContentIndex + this.contentChunkSize);
-            const chunkHash = (0, crypto_1.createHash)('sha256').update(currentChunk).digest('hex');
-            if (this.isLoopDetectedForChunk(currentChunk, chunkHash)) {
-                return true;
-            }
-            this.lastContentIndex++;
-        }
-        return false;
-    }
-    hasMoreChunksToProcess() {
-        return this.lastContentIndex + this.contentChunkSize <= this.streamContentHistory.length;
-    }
-    isLoopDetectedForChunk(chunk, hash) {
-        const existingIndices = this.contentStats.get(hash);
-        if (!existingIndices) {
-            this.contentStats.set(hash, [this.lastContentIndex]);
-            return false;
-        }
-        if (!this.isActualContentMatch(chunk, existingIndices[0])) {
-            return false;
-        }
-        existingIndices.push(this.lastContentIndex);
-        if (existingIndices.length < this.contentLoopThreshold) {
-            return false;
-        }
-        // Analyze the most recent occurrences to see if they're clustered closely together
-        const recentIndices = existingIndices.slice(-this.contentLoopThreshold);
-        const totalDistance = recentIndices[recentIndices.length - 1] - recentIndices[0];
-        const averageDistance = totalDistance / (this.contentLoopThreshold - 1);
-        const maxAllowedDistance = this.contentChunkSize * 1.5;
-        return averageDistance <= maxAllowedDistance;
-    }
-    isActualContentMatch(currentChunk, originalIndex) {
-        const originalChunk = this.streamContentHistory.substring(originalIndex, originalIndex + this.contentChunkSize);
-        return originalChunk === currentChunk;
-    }
-    resetContentTracking(resetHistory = true) {
-        if (resetHistory) {
-            this.streamContentHistory = '';
-        }
-        this.contentStats.clear();
-        this.lastContentIndex = 0;
-    }
-    reset() {
-        this.lastToolCallKey = null;
-        this.toolCallRepetitionCount = 0;
-        this.resetContentTracking();
-        this.turnsInCurrentPrompt = 0;
-        this.llmCheckInterval = this.defaultLLMCheckInterval;
-        this.lastCheckTurn = 0;
-        this.loopDetected = false;
-        this.inCodeBlock = false;
-    }
-}
-exports.AdvancedLoopDetectionProcessor = AdvancedLoopDetectionProcessor;

package/dist/processor-pieces/processors/chatCompressionProcessor.d.ts

@@ -1,26 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ChatCompressionInfo {
-    originalTokenCount: number;
-    newTokenCount: number;
-    compressionRatio: number;
-    threshold: number;
-}
-export interface ChatCompressionProcessorOptions {
-    compressionThreshold?: number;
-    compressionPreserveThreshold?: number;
-    tokenLimit?: number;
-    enableCompression?: boolean;
-}
-export declare class ChatCompressionProcessor extends BaseProcessor {
-    private readonly compressionThreshold;
-    private readonly compressionPreserveThreshold;
-    private readonly tokenLimit;
-    private readonly enableCompression;
-    constructor(options?: ChatCompressionProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private estimateTokenCount;
-    setCompressionThreshold(threshold: number): void;
-    setTokenLimit(limit: number): void;
-    enableCompressionForSession(): void;
-    disableCompressionForSession(): void;
-}

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

@@ -1,90 +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.ChatCompressionProcessor = void 0;
-const processor_1 = require("../../processor");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class ChatCompressionProcessor extends processor_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.compressionThreshold = options.compressionThreshold || 0.7;
-        this.compressionPreserveThreshold = options.compressionPreserveThreshold || 0.3;
-        this.tokenLimit = options.tokenLimit || 128000;
-        this.enableCompression = options.enableCompression !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            if (!this.enableCompression) {
-                return [this.createEvent('ChatCompressionDisabled', {
-                        reason: 'Compression is disabled for this session'
-                    })];
-            }
-            // Get chat history from CodeBolt
-            const chatHistory = await codeboltjs_1.default.chat.getChatHistory();
-            if (chatHistory.length === 0) {
-                return [this.createEvent('NoChatHistory', {
-                        reason: 'No chat history available for compression'
-                    })];
-            }
-            // Estimate token count (simple heuristic: 4 chars per token)
-            const estimatedTokens = this.estimateTokenCount(chatHistory);
-            const threshold = this.compressionThreshold * this.tokenLimit;
-            console.log(`[Compression] Estimated tokens: ${estimatedTokens}, threshold: ${threshold}`);
-            if (estimatedTokens < threshold) {
-                return [this.createEvent('ChatCompressionSkipped', {
-                        estimatedTokens,
-                        threshold,
-                        reason: 'Below compression threshold'
-                    })];
-            }
-            // Perform compression using CodeBolt's chatSummary
-            const compressionResult = await codeboltjs_1.default.chatSummary.summarizeAll();
-            if (compressionResult.success && compressionResult.data) {
-                const newTokenCount = this.estimateTokenCount(compressionResult.data);
-                const compressionInfo = {
-                    originalTokenCount: estimatedTokens,
-                    newTokenCount,
-                    compressionRatio: newTokenCount / estimatedTokens,
-                    threshold: this.compressionThreshold
-                };
-                // Send notification about compression
-                await codeboltjs_1.default.chat.sendNotificationEvent(`Chat compressed: ${estimatedTokens} → ${newTokenCount} tokens`, 'debug');
-                return [this.createEvent('ChatCompressed', compressionInfo)];
-            }
-            else {
-                return [this.createEvent('ChatCompressionFailed', {
-                        error: compressionResult.message || 'Unknown compression error',
-                        originalTokenCount: estimatedTokens
-                    })];
-            }
-        }
-        catch (error) {
-            console.error('Error in ChatCompressionProcessor:', error);
-            return [this.createEvent('ChatCompressionError', {
-                    error: error instanceof Error ? error.message : String(error)
-                })];
-        }
-    }
-    estimateTokenCount(data) {
-        // Simple heuristic: 4 characters per token
-        const totalContent = JSON.stringify(data);
-        return Math.ceil(totalContent.length / 4);
-    }
-    // Public methods for external control
-    setCompressionThreshold(threshold) {
-        this.compressionThreshold = Math.max(0.1, Math.min(0.9, threshold));
-    }
-    setTokenLimit(limit) {
-        this.tokenLimit = Math.max(1000, limit);
-    }
-    enableCompressionForSession() {
-        this.enableCompression = true;
-    }
-    disableCompressionForSession() {
-        this.enableCompression = false;
-    }
-}
-exports.ChatCompressionProcessor = ChatCompressionProcessor;

package/dist/processor-pieces/processors/chatRecordingProcessor.d.ts

@@ -1,81 +0,0 @@
-import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
-export interface ChatRecordingProcessorOptions {
-    enableTokenTracking?: boolean;
-    exportFormat?: 'json' | 'txt' | 'csv';
-    outputDirectory?: string;
-    maxFileSize?: number;
-    enableCompression?: boolean;
-    includeMetadata?: boolean;
-    autoExport?: boolean;
-    exportInterval?: number;
-}
-export interface TokensSummary {
-    input: number;
-    output: number;
-    cached: number;
-    thoughts?: number;
-    tool?: number;
-    total: number;
-}
-export interface MessageRecord {
-    id: string;
-    timestamp: string;
-    role: string;
-    content: string;
-    metadata?: Record<string, any>;
-    tokens?: TokensSummary;
-    toolCalls?: ToolCallRecord[];
-}
-export interface ToolCallRecord {
-    id: string;
-    name: string;
-    args: Record<string, unknown>;
-    result?: any;
-    status: 'pending' | 'success' | 'error' | 'cancelled';
-    timestamp: string;
-    executionTime?: number;
-}
-export interface ConversationSession {
-    sessionId: string;
-    startTime: string;
-    endTime?: string;
-    messages: MessageRecord[];
-    totalTokens: TokensSummary;
-    toolCallCount: number;
-    metadata: Record<string, any>;
-}
-export declare class ChatRecordingProcessor extends BaseProcessor {
-    private readonly enableTokenTracking;
-    private readonly exportFormat;
-    private readonly outputDirectory;
-    private readonly maxFileSize;
-    private readonly enableCompression;
-    private readonly includeMetadata;
-    private readonly autoExport;
-    private readonly exportInterval;
-    private currentSession;
-    private messageCount;
-    private sessions;
-    constructor(options?: ChatRecordingProcessorOptions);
-    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    private initializeSession;
-    private createMessageRecord;
-    private extractContent;
-    private extractToolCalls;
-    private estimateTokens;
-    private updateSessionTotals;
-    private generateSessionId;
-    private generateMessageId;
-    private generateToolCallId;
-    exportSession(session: ConversationSession): Promise<string>;
-    private ensureDirectoryExists;
-    private formatAsText;
-    private formatAsCSV;
-    finalizeSession(): Promise<string | null>;
-    getCurrentSession(): ConversationSession | null;
-    getSessionStats(): {
-        currentSessionMessages: number;
-        totalSessions: number;
-        totalMessages: number;
-    };
-}