@codebolt/agent 2.2.2 → 2.2.3

package/dist/processor-pieces/additionalModifiers/directoryContextModifier.js

@@ -0,0 +1,330 @@
+"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.DirectoryContextModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const MAX_ITEMS = 200;
+const TRUNCATION_INDICATOR = '...';
+const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
+// Error handling utility (simplified version of gemini-cli's getErrorMessage)
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    try {
+        return String(error);
+    }
+    catch {
+        return 'Failed to get error details';
+    }
+}
+// Node error type guard
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+class DirectoryContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            workspaceDirectories: options.workspaceDirectories || []
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            // Get workspace directories from codebolt or use provided options
+            let workspaceDirectories = this.options.workspaceDirectories;
+            if (!workspaceDirectories || workspaceDirectories.length === 0) {
+                const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+                workspaceDirectories = projectPath ? [projectPath] : [];
+            }
+            if (workspaceDirectories.length === 0) {
+                return createdMessage;
+            }
+            const folderStructures = await Promise.all(workspaceDirectories.map((dir) => this.getFolderStructure(dir)));
+            const folderStructure = folderStructures.join('\n');
+            let workingDirPreamble;
+            if (workspaceDirectories.length === 1) {
+                workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
+            }
+            else {
+                const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join('\n');
+                workingDirPreamble = `I'm currently working in the following directories:\n${dirList}`;
+            }
+            const directoryContext = `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+            const contextMessage = {
+                role: 'user', // Note: gemini-cli adds this as user message, not system
+                content: directoryContext
+            };
+            // Add as user message (like gemini-cli does)
+            const messages = [...createdMessage.message.messages, contextMessage];
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    directoryContextAdded: true,
+                    workspaceDirectories
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in DirectoryContextModifier:', error);
+            return createdMessage;
+        }
+    }
+    /**
+     * Generates a string representation of a directory's structure,
+     * limiting the number of items displayed. Ignored folders are shown
+     * followed by '...' instead of their contents.
+     *
+     * @param directory The absolute or relative path to the directory.
+     * @param options Optional configuration settings.
+     * @returns A promise resolving to the formatted folder structure string.
+     */
+    async getFolderStructure(directory, options) {
+        var _a, _b;
+        const resolvedPath = path.resolve(directory);
+        const mergedOptions = {
+            maxItems: (_a = options === null || options === void 0 ? void 0 : options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
+            ignoredFolders: (_b = options === null || options === void 0 ? void 0 : options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
+            fileIncludePattern: options === null || options === void 0 ? void 0 : options.fileIncludePattern,
+        };
+        try {
+            // 1. Read the structure using BFS, respecting maxItems
+            const structureRoot = await this.readFullStructure(resolvedPath, mergedOptions);
+            if (!structureRoot) {
+                return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
+            }
+            // 2. Format the structure into a string
+            const structureLines = [];
+            // Pass true for isRoot for the initial call
+            this.formatStructure(structureRoot, '', true, true, structureLines);
+            // 3. Build the final output string
+            function isTruncated(node) {
+                if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+                    return true;
+                }
+                for (const sub of node.subFolders) {
+                    if (isTruncated(sub)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
+            if (isTruncated(structureRoot)) {
+                summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.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}": ${getErrorMessage(error)}`;
+        }
+    }
+    async readFullStructure(rootPath, options) {
+        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;
+        // Count the root node itself as one item if we are not just listing its content
+        const processedPaths = new Set(); // To avoid processing same path if symlinks create loops
+        while (queue.length > 0) {
+            const { folderInfo, currentPath } = queue.shift();
+            if (processedPaths.has(currentPath)) {
+                continue;
+            }
+            processedPaths.add(currentPath);
+            if (currentItemCount >= options.maxItems) {
+                // If the root itself caused us to exceed, we can't really show anything.
+                // Otherwise, this folder won't be processed further.
+                // The parent that queued this would have set its own hasMoreSubfolders flag.
+                continue;
+            }
+            let entries;
+            try {
+                const rawEntries = await fs.readdir(currentPath, { withFileTypes: true });
+                // Sort entries alphabetically by name for consistent processing order
+                entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            catch (error) {
+                if (isNodeError(error) &&
+                    (error.code === 'EACCES' || error.code === 'ENOENT')) {
+                    console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+                    if (currentPath === rootPath && error.code === 'ENOENT') {
+                        return null; // Root directory itself not found
+                    }
+                    // For other EACCES/ENOENT on subdirectories, just skip them.
+                    continue;
+                }
+                throw error;
+            }
+            const filesInCurrentDir = [];
+            const subFoldersInCurrentDir = [];
+            // Process files first in the current directory
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    if (currentItemCount >= options.maxItems) {
+                        folderInfo.hasMoreFiles = true;
+                        break;
+                    }
+                    const fileName = entry.name;
+                    if (!options.fileIncludePattern ||
+                        options.fileIncludePattern.test(fileName)) {
+                        filesInCurrentDir.push(fileName);
+                        currentItemCount++;
+                        folderInfo.totalFiles++;
+                        folderInfo.totalChildren++;
+                    }
+                }
+            }
+            folderInfo.files = filesInCurrentDir;
+            // Then process directories and queue them
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    // Check if adding this directory ITSELF would meet or exceed maxItems
+                    // (currentItemCount refers to items *already* added before this one)
+                    if (currentItemCount >= options.maxItems) {
+                        folderInfo.hasMoreSubfolders = true;
+                        break; // Already at limit, cannot add this folder or any more
+                    }
+                    // If adding THIS folder makes us hit the limit exactly, and it might have children,
+                    // it's better to show '...' for the parent, unless this is the very last item slot.
+                    // This logic is tricky. Let's try a simpler: if we can't add this item, mark and break.
+                    const subFolderName = entry.name;
+                    const subFolderPath = path.join(currentPath, subFolderName);
+                    if (options.ignoredFolders.has(subFolderName)) {
+                        const ignoredSubFolder = {
+                            name: subFolderName,
+                            path: subFolderPath,
+                            files: [],
+                            subFolders: [],
+                            totalChildren: 0,
+                            totalFiles: 0,
+                            isIgnored: true,
+                        };
+                        subFoldersInCurrentDir.push(ignoredSubFolder);
+                        currentItemCount++; // Count the ignored folder itself
+                        folderInfo.totalChildren++; // Also counts towards parent's children
+                        continue;
+                    }
+                    const subFolderNode = {
+                        name: subFolderName,
+                        path: subFolderPath,
+                        files: [],
+                        subFolders: [],
+                        totalChildren: 0,
+                        totalFiles: 0,
+                    };
+                    subFoldersInCurrentDir.push(subFolderNode);
+                    currentItemCount++;
+                    folderInfo.totalChildren++; // Counts towards parent's children
+                    // Add to queue for processing its children later
+                    queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
+                }
+            }
+            folderInfo.subFolders = subFoldersInCurrentDir;
+        }
+        return rootNode;
+    }
+    /**
+     * Reads the directory structure using BFS, respecting maxItems.
+     * @param node The current node in the reduced structure.
+     * @param indent The current indentation string.
+     * @param isLast Sibling indicator.
+     * @param builder Array to build the string lines.
+     */
+    formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
+        const connector = isLastChildOfParent ? '└───' : '├───';
+        // The root node of the structure (the one passed initially to getFolderStructure)
+        // is not printed with a connector line itself, only its name as a header.
+        // Its children are printed relative to that conceptual root.
+        // Ignored root nodes ARE printed with a connector.
+        if (!isProcessingRootNode || node.isIgnored) {
+            builder.push(`${currentIndent}${connector}${node.name}${path.sep}${node.isIgnored ? TRUNCATION_INDICATOR : ''}`);
+        }
+        // Determine the indent for the children of *this* node.
+        // If *this* node was the root of the whole structure, its children start with no indent before their connectors.
+        // Otherwise, children's indent extends from the current node's indent.
+        const indentForChildren = isProcessingRootNode
+            ? ''
+            : currentIndent + (isLastChildOfParent ? '    ' : '│   ');
+        // Render files of the current node
+        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}${TRUNCATION_INDICATOR}`);
+        }
+        // Render subfolders of the current node
+        const subFolderCount = node.subFolders.length;
+        for (let i = 0; i < subFolderCount; i++) {
+            const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
+            // Children are never the root node being processed initially.
+            this.formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+        }
+        if (node.hasMoreSubfolders) {
+            builder.push(`${indentForChildren}└───${TRUNCATION_INDICATOR}`);
+        }
+    }
+}
+exports.DirectoryContextModifier = DirectoryContextModifier;

package/dist/processor-pieces/additionalModifiers/environmentContextModifier.d.ts

@@ -0,0 +1,26 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface EnvironmentContextOptions {
+    enableFullContext?: boolean;
+    maxFiles?: number;
+    maxFileSize?: number;
+    includePatterns?: string[];
+    excludePatterns?: string[];
+}
+export declare class EnvironmentContextModifier extends BaseMessageModifier {
+    private readonly options;
+    private readonly defaultExcludePatterns;
+    constructor(options?: EnvironmentContextOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private generateFullContext;
+    private findRelevantFiles;
+    private walkDirectory;
+    private isExcluded;
+    private isIncluded;
+    private matchesPattern;
+    private countContextFiles;
+    enableFullContext(): void;
+    disableFullContext(): void;
+    isFullContextEnabled(): boolean;
+}

package/dist/processor-pieces/additionalModifiers/environmentContextModifier.js

@@ -0,0 +1,269 @@
+"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.EnvironmentContextModifier = void 0;
+const base_1 = require("../base");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class EnvironmentContextModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.defaultExcludePatterns = [
+            'node_modules/**',
+            '.git/**',
+            'dist/**',
+            'build/**',
+            '*.log',
+            '*.tmp',
+            '.DS_Store',
+            'coverage/**',
+            '.next/**',
+            '.nuxt/**'
+        ];
+        this.options = {
+            enableFullContext: options.enableFullContext || false,
+            maxFiles: options.maxFiles || 100,
+            maxFileSize: options.maxFileSize || 100 * 1024, // 100KB per file
+            includePatterns: options.includePatterns || ['**/*.ts', '**/*.js', '**/*.json', '**/*.md', '**/*.txt', '**/*.yml', '**/*.yaml'],
+            excludePatterns: [...this.defaultExcludePatterns, ...(options.excludePatterns || [])]
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            // Get current date formatted to user's locale
+            const today = new Date().toLocaleDateString(undefined, {
+                weekday: 'long',
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric',
+            });
+            const platform = process.platform;
+            const { projectPath } = await codeboltjs_1.default.project.getProjectPath();
+            if (!projectPath) {
+                return createdMessage;
+            }
+            const currentDir = projectPath;
+            // Get basic directory listing
+            let directoryListing = '';
+            try {
+                const files = await fs.promises.readdir(currentDir);
+                const fileList = files.slice(0, 20).join(', '); // Limit to first 20 files
+                const moreFiles = files.length > 20 ? ` ... and ${files.length - 20} more files` : '';
+                directoryListing = `Files in current directory: ${fileList}${moreFiles}`;
+            }
+            catch (error) {
+                directoryListing = 'Unable to read current directory';
+            }
+            const environmentContext = `
+This is the CodeBolt AI Agent. Setting up context for our chat.
+Today's date is ${today} (formatted according to the user's locale).
+Operating system: ${platform}
+Current working directory: ${currentDir}
+${directoryListing}
+            `.trim();
+            // Prepare context parts (same as gemini-cli)
+            const contextParts = [environmentContext];
+            // Add full file context if enabled (just like gemini-cli does)
+            if (this.options.enableFullContext) {
+                try {
+                    const fullContextContent = await this.generateFullContext(currentDir);
+                    if (fullContextContent) {
+                        contextParts.push(`\n--- Full File Context ---\n${fullContextContent}`);
+                    }
+                }
+                catch (error) {
+                    console.error('Error reading full file context:', error);
+                    contextParts.push('\n--- Error reading full file context ---');
+                }
+            }
+            const finalContent = contextParts.join('\n\n');
+            const contextMessage = {
+                role: 'system',
+                content: finalContent
+            };
+            // Find existing system message or add new one
+            const messages = [...createdMessage.message.messages];
+            const systemMessageIndex = messages.findIndex(msg => msg.role === 'system');
+            if (systemMessageIndex !== -1) {
+                // Append to existing system message
+                messages[systemMessageIndex] = {
+                    ...messages[systemMessageIndex],
+                    content: `${messages[systemMessageIndex].content}\n\n${finalContent}`
+                };
+            }
+            else {
+                // Add new system message at the beginning
+                messages.unshift(contextMessage);
+            }
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    environmentContextAdded: true,
+                    fullContextAdded: this.options.enableFullContext,
+                    contextFilesCount: this.options.enableFullContext ? await this.countContextFiles(currentDir) : 0,
+                    environmentInfo: {
+                        date: today,
+                        platform,
+                        currentDir
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in EnvironmentContextModifier:', error);
+            return createdMessage;
+        }
+    }
+    // Full context methods (integrated like gemini-cli)
+    async generateFullContext(basePath) {
+        try {
+            const files = await this.findRelevantFiles(basePath);
+            const contextParts = [];
+            let processedFiles = 0;
+            for (const filePath of files) {
+                if (processedFiles >= this.options.maxFiles) {
+                    contextParts.push(`\n... (${files.length - processedFiles} more files not shown due to limit)\n`);
+                    break;
+                }
+                try {
+                    const relativePath = path.relative(basePath, filePath);
+                    const stats = await fs.promises.stat(filePath);
+                    // Skip files that are too large
+                    if (stats.size > this.options.maxFileSize) {
+                        contextParts.push(`--- ${relativePath} ---\n[File too large: ${stats.size} bytes]\n`);
+                        processedFiles++;
+                        continue;
+                    }
+                    const content = await fs.promises.readFile(filePath, 'utf-8');
+                    contextParts.push(`--- ${relativePath} ---\n${content}\n`);
+                    processedFiles++;
+                }
+                catch (error) {
+                    const relativePath = path.relative(basePath, filePath);
+                    contextParts.push(`--- ${relativePath} ---\n[Error reading file: ${error instanceof Error ? error.message : 'Unknown error'}]\n`);
+                    processedFiles++;
+                }
+            }
+            return contextParts.join('\n');
+        }
+        catch (error) {
+            console.error('Error generating full context:', error);
+            return '';
+        }
+    }
+    async findRelevantFiles(basePath) {
+        const files = [];
+        try {
+            await this.walkDirectory(basePath, files, basePath);
+            return files.sort();
+        }
+        catch (error) {
+            console.error('Error finding relevant files:', error);
+            return [];
+        }
+    }
+    async walkDirectory(dir, files, basePath) {
+        try {
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                const relativePath = path.relative(basePath, fullPath);
+                // Check exclusion patterns
+                if (this.isExcluded(relativePath)) {
+                    continue;
+                }
+                if (entry.isDirectory()) {
+                    await this.walkDirectory(fullPath, files, basePath);
+                }
+                else if (entry.isFile()) {
+                    // Check inclusion patterns
+                    if (this.isIncluded(relativePath)) {
+                        files.push(fullPath);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    isExcluded(relativePath) {
+        return this.options.excludePatterns.some(pattern => {
+            return this.matchesPattern(relativePath, pattern);
+        });
+    }
+    isIncluded(relativePath) {
+        return this.options.includePatterns.some(pattern => {
+            return this.matchesPattern(relativePath, pattern);
+        });
+    }
+    matchesPattern(filePath, pattern) {
+        // Simple glob pattern matching - in production, use a proper glob library
+        const regexPattern = pattern
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        return regex.test(filePath);
+    }
+    async countContextFiles(basePath) {
+        try {
+            const files = await this.findRelevantFiles(basePath);
+            return Math.min(files.length, this.options.maxFiles);
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    // Public methods to control full context
+    enableFullContext() {
+        this.options.enableFullContext = true;
+    }
+    disableFullContext() {
+        this.options.enableFullContext = false;
+    }
+    isFullContextEnabled() {
+        return this.options.enableFullContext || false;
+    }
+}
+exports.EnvironmentContextModifier = EnvironmentContextModifier;

package/dist/processor-pieces/additionalModifiers/fallbackHandlerModifier.d.ts

@@ -0,0 +1,38 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface FallbackHandlerOptions {
+    enableFallback?: boolean;
+    maxRetries?: number;
+    fallbackStrategies?: FallbackStrategy[];
+    timeoutMs?: number;
+}
+export declare enum FallbackStrategy {
+    RETRY_WITH_SIMPLIFIED_CONTEXT = "retry_simplified",
+    RETRY_WITHOUT_TOOLS = "retry_no_tools",
+    RETRY_WITH_SHORTER_HISTORY = "retry_short_history",
+    USE_FALLBACK_MODEL = "fallback_model",
+    PROVIDE_ERROR_CONTEXT = "error_context"
+}
+export declare class FallbackHandlerModifier extends BaseMessageModifier {
+    private readonly options;
+    private fallbackContexts;
+    constructor(options?: FallbackHandlerOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private generateMessageId;
+    private shouldApplyFallback;
+    private initializeFallbackContext;
+    private applyFallbackStrategy;
+    private getNextFallbackStrategy;
+    private simplifyContext;
+    private removeTools;
+    private shortenHistory;
+    private setFallbackModel;
+    private addErrorContextMessage;
+    private updateFallbackContext;
+    clearFallbackContext(messageId: string): void;
+    getFallbackStats(): {
+        totalContexts: number;
+        averageAttempts: number;
+    };
+}