@codebolt/agent 1.2.1 → 2.2.3

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

@@ -0,0 +1,392 @@
+"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 base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+class WorkingDirectoryMessageModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super({ context: options });
+        this.defaultIgnoredFolders = new Set(['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents']);
+        this.truncationIndicator = '...';
+        this.showFolderStructureSummary = options.showFolderStructureSummary || false;
+        this.listFiles = options.listFiles || false;
+        this.listFilesDepth = options.listFilesDepth || 2;
+        this.listFilesLimit = options.listFilesLimit || 100;
+        this.listFilesIgnoreFromGitignore = options.listFilesIgnoreFromGitignore || true;
+        this.listFilesIgnore = options.listFilesIgnore || ['node_modules', '.git', 'dist', '.codebolt', '.codeboltAgents'];
+        this.maxItems = options.maxItems || 200;
+        this.showFullDirectoryContext = options.showFullDirectoryContext || true;
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const contextParts = [];
+            // Get project information
+            try {
+                const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+                if (!projectPath) {
+                    throw new Error('Project path not available');
+                }
+                // Generate comprehensive directory context similar to gemini-cli
+                if (this.showFullDirectoryContext) {
+                    const directoryContext = await this.getDirectoryContextString(projectPath);
+                    contextParts.push(directoryContext);
+                }
+                else {
+                    // Fallback to original behavior
+                    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 contextContent = contextParts.join('\n\n');
+                const messages = [...createdMessage.message.messages];
+                // Find existing system message
+                const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+                if (systemMessageIndex !== -1) {
+                    // Update existing system message
+                    messages[systemMessageIndex] = {
+                        ...messages[systemMessageIndex],
+                        content: `${messages[systemMessageIndex].content}\n\n${contextContent}`
+                    };
+                }
+                else {
+                    // Add new system message at the top
+                    messages.unshift({
+                        role: 'system',
+                        content: contextContent
+                    });
+                }
+                return {
+                    ...createdMessage,
+                    message: {
+                        ...createdMessage.message,
+                        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 {
+            const directories = new Set();
+            await this.collectDirectories(projectPath, directories, 0, 3); // Max depth of 3
+            const sortedDirs = Array.from(directories)
+                .filter(dir => dir !== projectPath && !this.shouldIgnore(dir))
+                .sort()
+                .slice(0, 20);
+            return sortedDirs.length > 0
+                ? sortedDirs.join('\n')
+                : 'No accessible directories found';
+        }
+        catch (error) {
+            return 'Unable to generate folder structure summary';
+        }
+    }
+    async generateFilesList(projectPath) {
+        try {
+            const files = [];
+            await this.collectFiles(projectPath, files, 0, 2); // Max depth of 2
+            const filteredFiles = files
+                .filter(filePath => !this.shouldIgnore(filePath))
+                .slice(0, this.listFilesLimit)
+                .map(filePath => path.basename(filePath));
+            return filteredFiles.length > 0
+                ? filteredFiles.join('\n')
+                : 'No accessible files found';
+        }
+        catch (error) {
+            return 'Unable to generate files list';
+        }
+    }
+    async collectDirectories(dirPath, directories, currentDepth, maxDepth) {
+        if (currentDepth >= maxDepth)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        directories.add(fullPath);
+                        await this.collectDirectories(fullPath, directories, currentDepth + 1, maxDepth);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    async collectFiles(dirPath, files, currentDepth, maxDepth) {
+        if (currentDepth >= maxDepth || files.length >= this.listFilesLimit)
+            return;
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        files.push(fullPath);
+                        if (files.length >= this.listFilesLimit)
+                            break;
+                    }
+                }
+                else if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (!this.shouldIgnore(fullPath)) {
+                        await this.collectFiles(fullPath, files, currentDepth + 1, maxDepth);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    shouldIgnore(filePath) {
+        const basename = path.basename(filePath);
+        // Ignore any folder/file that starts with a dot
+        if (basename.startsWith('.')) {
+            return true;
+        }
+        return this.listFilesIgnore.some(ignore => filePath.includes(ignore) || basename === ignore);
+    }
+    // Comprehensive directory context methods exactly like gemini-cli
+    async getDirectoryContextString(projectPath) {
+        const folderStructure = await this.getFolderStructure(projectPath);
+        const workingDirPreamble = `I'm currently working in the directory: ${projectPath}`;
+        return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+    }
+    async getFolderStructure(directory) {
+        const resolvedPath = path.resolve(directory);
+        try {
+            const structureRoot = await this.readFullStructure(resolvedPath);
+            if (!structureRoot) {
+                return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
+            }
+            const structureLines = [];
+            this.formatStructure(structureRoot, '', true, true, structureLines);
+            const isTruncated = this.isTruncated(structureRoot);
+            let summary = `Showing up to ${this.maxItems} items (files + folders).`;
+            if (isTruncated) {
+                summary += ` Folders or files indicated with ${this.truncationIndicator} contain more items not shown, were ignored, or the display limit (${this.maxItems} items) was reached.`;
+            }
+            return `${summary}\n\n${resolvedPath}${path.sep}\n${structureLines.join('\n')}`;
+        }
+        catch (error) {
+            console.error(`Error getting folder structure for ${resolvedPath}:`, error);
+            return `Error processing directory "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`;
+        }
+    }
+    async readFullStructure(rootPath) {
+        const rootName = path.basename(rootPath);
+        const rootNode = {
+            name: rootName,
+            path: rootPath,
+            files: [],
+            subFolders: [],
+            totalChildren: 0,
+            totalFiles: 0,
+        };
+        const queue = [
+            { folderInfo: rootNode, currentPath: rootPath },
+        ];
+        let currentItemCount = 0;
+        const processedPaths = new Set();
+        while (queue.length > 0) {
+            const { folderInfo, currentPath } = queue.shift();
+            if (processedPaths.has(currentPath)) {
+                continue;
+            }
+            processedPaths.add(currentPath);
+            if (currentItemCount >= this.maxItems) {
+                continue;
+            }
+            let entries;
+            try {
+                const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
+                entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            catch (error) {
+                if (error.code === 'EACCES' || error.code === 'ENOENT') {
+                    console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+                    if (currentPath === rootPath && error.code === 'ENOENT') {
+                        return null;
+                    }
+                    continue;
+                }
+                throw error;
+            }
+            const filesInCurrentDir = [];
+            const subFoldersInCurrentDir = [];
+            // Process files first
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    if (currentItemCount >= this.maxItems) {
+                        folderInfo.hasMoreFiles = true;
+                        break;
+                    }
+                    const fileName = entry.name;
+                    const filePath = path.join(currentPath, fileName);
+                    if (!this.shouldIgnore(filePath)) {
+                        filesInCurrentDir.push(fileName);
+                        currentItemCount++;
+                        folderInfo.totalFiles++;
+                        folderInfo.totalChildren++;
+                    }
+                }
+            }
+            folderInfo.files = filesInCurrentDir;
+            // Process directories
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    if (currentItemCount >= this.maxItems) {
+                        folderInfo.hasMoreSubfolders = true;
+                        break;
+                    }
+                    const subFolderName = entry.name;
+                    const subFolderPath = path.join(currentPath, subFolderName);
+                    const isIgnored = this.defaultIgnoredFolders.has(subFolderName) ||
+                        subFolderName.startsWith('.') ||
+                        this.shouldIgnore(subFolderPath);
+                    if (isIgnored) {
+                        const ignoredSubFolder = {
+                            name: subFolderName,
+                            path: subFolderPath,
+                            files: [],
+                            subFolders: [],
+                            totalChildren: 0,
+                            totalFiles: 0,
+                            isIgnored: true,
+                        };
+                        subFoldersInCurrentDir.push(ignoredSubFolder);
+                        currentItemCount++;
+                        folderInfo.totalChildren++;
+                        continue;
+                    }
+                    const subFolderNode = {
+                        name: subFolderName,
+                        path: subFolderPath,
+                        files: [],
+                        subFolders: [],
+                        totalChildren: 0,
+                        totalFiles: 0,
+                    };
+                    subFoldersInCurrentDir.push(subFolderNode);
+                    currentItemCount++;
+                    folderInfo.totalChildren++;
+                    queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
+                }
+            }
+            folderInfo.subFolders = subFoldersInCurrentDir;
+        }
+        return rootNode;
+    }
+    formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
+        const connector = isLastChildOfParent ? '└───' : '├───';
+        if (!isProcessingRootNode || node.isIgnored) {
+            builder.push(`${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? this.truncationIndicator : ''}`);
+        }
+        const indentForChildren = isProcessingRootNode
+            ? ''
+            : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
+        // Render files
+        const fileCount = node.files.length;
+        for (let i = 0; i < fileCount; i++) {
+            const isLastFileAmongSiblings = i === fileCount - 1 &&
+                node.subFolders.length === 0 &&
+                !node.hasMoreSubfolders;
+            const fileConnector = isLastFileAmongSiblings ? '└───' : '├───';
+            builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
+        }
+        if (node.hasMoreFiles) {
+            const isLastIndicatorAmongSiblings = node.subFolders.length === 0 && !node.hasMoreSubfolders;
+            const fileConnector = isLastIndicatorAmongSiblings ? '└───' : '├───';
+            builder.push(`${indentForChildren}${fileConnector}${this.truncationIndicator}`);
+        }
+        // Render subfolders
+        const subFolderCount = node.subFolders.length;
+        for (let i = 0; i < subFolderCount; i++) {
+            const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
+            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+        }
+        if (node.hasMoreSubfolders) {
+            builder.push(`${indentForChildren}└───${this.truncationIndicator}`);
+        }
+    }
+    isTruncated(node) {
+        if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+            return true;
+        }
+        for (const sub of node.subFolders) {
+            if (this.isTruncated(sub)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.WorkingDirectoryMessageModifier = WorkingDirectoryMessageModifier;

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.d.ts

@@ -0,0 +1,7 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePostInferenceProcessor } from "../base";
+import { LLMResponse } from "@codebolt/types/sdk";
+export declare class CheckForNoToolCall extends BasePostInferenceProcessor {
+    constructor();
+    modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckForNoToolCall = void 0;
+const base_1 = require("../base");
+class CheckForNoToolCall extends base_1.BasePostInferenceProcessor {
+    constructor() {
+        super();
+    }
+    modify(llmMessageSent, llmResponseMessage, nextPrompt) {
+        // Check if tool_calls exist in the LLM response
+        const hasToolCalls = llmResponseMessage.tool_calls && llmResponseMessage.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            // Create a new message indicating no tool call was found
+            const noToolCallMessage = {
+                role: 'user',
+                content: 'no tool call found in request'
+            };
+            nextPrompt.message.messages.push(noToolCallMessage);
+        }
+        // If tool calls exist, return the nextPrompt unchanged
+        return Promise.resolve(nextPrompt);
+    }
+}
+exports.CheckForNoToolCall = CheckForNoToolCall;

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.d.ts

@@ -0,0 +1,29 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePostInferenceProcessor } from "../base";
+import { LLMResponse } from "@codebolt/types/sdk";
+export interface LoopDetectionOptions {
+    maxSimilarMessages?: number;
+    similarityThreshold?: number;
+    timeWindowMs?: number;
+    enableLoopPrevention?: boolean;
+}
+interface MessageHistory {
+    content: string;
+    timestamp: number;
+    role: string;
+}
+export declare class LoopDetectionModifier extends BasePostInferenceProcessor {
+    private readonly options;
+    private messageHistory;
+    private loopDetected;
+    constructor(options?: LoopDetectionOptions);
+    modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
+    private detectLoop;
+    private checkSimilarMessages;
+    private calculateSimilarity;
+    private levenshteinDistance;
+    private cleanOldMessages;
+    resetLoopDetection(): void;
+    getMessageHistory(): MessageHistory[];
+}
+export {};

package/dist/processor-pieces/postInferenceProcessors/loopDetectionModifier.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionModifier = void 0;
+const base_1 = require("../base");
+class LoopDetectionModifier extends base_1.BasePostInferenceProcessor {
+    constructor(options = {}) {
+        super();
+        this.messageHistory = [];
+        this.loopDetected = false;
+        this.options = {
+            maxSimilarMessages: options.maxSimilarMessages || 3,
+            similarityThreshold: options.similarityThreshold || 0.8,
+            timeWindowMs: options.timeWindowMs || 60000, // 1 minute
+            enableLoopPrevention: options.enableLoopPrevention !== false
+        };
+    }
+    modify(llmMessageSent, llmResponseMessage, nextPrompt) {
+        try {
+            if (!this.options.enableLoopPrevention) {
+                return Promise.resolve(nextPrompt);
+            }
+            const currentTime = Date.now();
+            // Add LLM response to history
+            if (llmResponseMessage.content) {
+                this.messageHistory.push({
+                    content: llmResponseMessage.content,
+                    timestamp: currentTime,
+                    role: llmResponseMessage.role
+                });
+            }
+            // Add any choice messages from LLM response to history
+            if (llmResponseMessage.choices) {
+                for (const choice of llmResponseMessage.choices) {
+                    if (choice.message && choice.message.content) {
+                        this.messageHistory.push({
+                            content: choice.message.content,
+                            timestamp: currentTime,
+                            role: choice.message.role
+                        });
+                    }
+                }
+            }
+            // Add the original sent message to history if it exists
+            for (const message of llmMessageSent.message.messages) {
+                if (typeof message.content === 'string') {
+                    this.messageHistory.push({
+                        content: message.content,
+                        timestamp: currentTime,
+                        role: message.role
+                    });
+                }
+            }
+            // Clean old messages from history
+            this.cleanOldMessages(currentTime);
+            // Check for loops
+            const loopDetected = this.detectLoop();
+            if (loopDetected && !this.loopDetected) {
+                this.loopDetected = true;
+                // Add loop detection warning to the next prompt
+                const warningMessage = {
+                    role: 'system',
+                    content: `[Loop Detection Warning] Similar messages detected in recent conversation. This may indicate a conversational loop. Consider rephrasing your request or providing more specific information.`
+                };
+                const updatedMessages = [...nextPrompt.message.messages, warningMessage];
+                return Promise.resolve({
+                    message: {
+                        ...nextPrompt.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...nextPrompt.metadata,
+                        loopDetected: true,
+                        loopDetectionWarningAdded: true
+                    }
+                });
+            }
+            // Reset loop detection if we haven't detected a loop recently
+            if (!loopDetected && this.loopDetected) {
+                this.loopDetected = false;
+            }
+            return Promise.resolve({
+                message: nextPrompt.message,
+                metadata: {
+                    ...nextPrompt.metadata,
+                    loopDetectionChecked: true,
+                    loopDetected: false
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in LoopDetectionModifier:', error);
+            return Promise.resolve(nextPrompt);
+        }
+    }
+    detectLoop() {
+        if (this.messageHistory.length < this.options.maxSimilarMessages) {
+            return false;
+        }
+        // Get recent messages grouped by role
+        const recentUserMessages = this.messageHistory
+            .filter(msg => msg.role === 'user')
+            .slice(-this.options.maxSimilarMessages);
+        const recentAssistantMessages = this.messageHistory
+            .filter(msg => msg.role === 'assistant')
+            .slice(-this.options.maxSimilarMessages);
+        // Check for similar user messages
+        if (recentUserMessages.length >= this.options.maxSimilarMessages) {
+            const userLoop = this.checkSimilarMessages(recentUserMessages);
+            if (userLoop)
+                return true;
+        }
+        // Check for similar assistant messages
+        if (recentAssistantMessages.length >= this.options.maxSimilarMessages) {
+            const assistantLoop = this.checkSimilarMessages(recentAssistantMessages);
+            if (assistantLoop)
+                return true;
+        }
+        return false;
+    }
+    checkSimilarMessages(messages) {
+        if (messages.length < 2)
+            return false;
+        // Compare each message with every other message
+        for (let i = 0; i < messages.length - 1; i++) {
+            for (let j = i + 1; j < messages.length; j++) {
+                const similarity = this.calculateSimilarity(messages[i].content, messages[j].content);
+                if (similarity >= this.options.similarityThreshold) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    calculateSimilarity(text1, text2) {
+        // Simple similarity calculation using Levenshtein distance
+        const distance = this.levenshteinDistance(text1.toLowerCase(), text2.toLowerCase());
+        const maxLength = Math.max(text1.length, text2.length);
+        if (maxLength === 0)
+            return 1;
+        return 1 - (distance / maxLength);
+    }
+    levenshteinDistance(str1, str2) {
+        const matrix = [];
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+    cleanOldMessages(currentTime) {
+        const cutoffTime = currentTime - this.options.timeWindowMs;
+        this.messageHistory = this.messageHistory.filter(msg => msg.timestamp >= cutoffTime);
+    }
+    resetLoopDetection() {
+        this.messageHistory = [];
+        this.loopDetected = false;
+    }
+    getMessageHistory() {
+        return [...this.messageHistory];
+    }
+}
+exports.LoopDetectionModifier = LoopDetectionModifier;

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

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