@codebolt/agent 2.2.2 → 2.2.5

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

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionModifier = void 0;
+const base_1 = require("../base");
+class ChatCompressionModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.hasFailedCompressionAttempt = false;
+        this.options = {
+            tokenThreshold: options.tokenThreshold || 8000, // Approximate token threshold
+            compressionRatio: options.compressionRatio || 0.5, // Compress to 50% of original
+            preserveRecentMessages: options.preserveRecentMessages || 5,
+            enableCompression: options.enableCompression !== false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableCompression || this.hasFailedCompressionAttempt) {
+                return createdMessage;
+            }
+            const messages = createdMessage.message.messages;
+            // Skip compression if we don't have enough messages
+            if (messages.length <= this.options.preserveRecentMessages) {
+                return createdMessage;
+            }
+            const shouldCompress = await this.shouldCompressChat(messages);
+            if (!shouldCompress) {
+                return createdMessage;
+            }
+            const compressedMessages = await this.compressMessages(messages);
+            return Promise.resolve({
+                message: {
+                    ...createdMessage.message,
+                    messages: compressedMessages
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    chatCompressed: true,
+                    originalMessageCount: messages.length,
+                    compressedMessageCount: compressedMessages.length
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionModifier:', error);
+            this.hasFailedCompressionAttempt = true;
+            return createdMessage;
+        }
+    }
+    async shouldCompressChat(messages) {
+        // Estimate token count (rough approximation: 4 characters per token)
+        const totalCharacters = messages.reduce((sum, msg) => {
+            return sum + (typeof msg.content === 'string' ? msg.content.length : JSON.stringify(msg.content).length);
+        }, 0);
+        const estimatedTokens = totalCharacters / 4;
+        return estimatedTokens > this.options.tokenThreshold;
+    }
+    async compressMessages(messages) {
+        const preserveCount = this.options.preserveRecentMessages;
+        const recentMessages = messages.slice(-preserveCount);
+        const messagesToCompress = messages.slice(0, -preserveCount);
+        if (messagesToCompress.length === 0) {
+            return messages;
+        }
+        // Create a summary of the messages to compress
+        const conversationSummary = this.createConversationSummary(messagesToCompress);
+        const compressionMessage = {
+            role: 'system',
+            content: `[Conversation Summary - Previous ${messagesToCompress.length} messages compressed]
+
+${conversationSummary}
+
+[End of Summary - Continuing with recent conversation...]`
+        };
+        return [compressionMessage, ...recentMessages];
+    }
+    createConversationSummary(messages) {
+        const summaryParts = [];
+        let currentTopic = '';
+        let userQuestions = [];
+        let assistantResponses = [];
+        for (const message of messages) {
+            const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+            if (message.role === 'user') {
+                // Extract key questions or requests
+                if (content.length > 20) { // Only include substantial messages
+                    userQuestions.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
+                }
+            }
+            else if (message.role === 'assistant') {
+                // Extract key responses or actions
+                if (content.length > 20) {
+                    assistantResponses.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
+                }
+            }
+        }
+        if (userQuestions.length > 0) {
+            summaryParts.push(`Key user requests: ${userQuestions.slice(0, 3).join('; ')}`);
+        }
+        if (assistantResponses.length > 0) {
+            summaryParts.push(`Key assistant actions: ${assistantResponses.slice(0, 3).join('; ')}`);
+        }
+        summaryParts.push(`Total messages compressed: ${messages.length}`);
+        return summaryParts.join('\n');
+    }
+    resetCompressionState() {
+        this.hasFailedCompressionAttempt = false;
+    }
+}
+exports.ChatCompressionModifier = ChatCompressionModifier;

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.example.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Example usage of ChatHistoryMessageModifier
+ *
+ * This file demonstrates how to integrate chat history into your agent's message processing pipeline.
+ */
+import { InitialPromptGenerator } from '@codebolt/agent/unified';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+export declare function createBasicChatHistoryAgent(): InitialPromptGenerator;
+export declare function createCompactChatHistoryAgent(): InitialPromptGenerator;
+export declare function createThreadAwareChatHistoryAgent(): InitialPromptGenerator;
+export declare function processMessageWithHistory(userMessage: FlatUserMessage): Promise<import("@codebolt/types/agent").ProcessedMessage>;
+export declare const chatHistoryOptions: {
+    enableChatHistory: boolean;
+    maxHistoryMessages: number;
+    includeSystemMessages: boolean;
+    historyContextLabel: string;
+    filterByThreadId: boolean;
+    includeTimestamps: boolean;
+    compactFormat: boolean;
+};

package/dist/processor-pieces/messageModifiers/chatHistoryMessageModifier.example.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Example usage of ChatHistoryMessageModifier
+ *
+ * This file demonstrates how to integrate chat history into your agent's message processing pipeline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatHistoryOptions = void 0;
+exports.createBasicChatHistoryAgent = createBasicChatHistoryAgent;
+exports.createCompactChatHistoryAgent = createCompactChatHistoryAgent;
+exports.createThreadAwareChatHistoryAgent = createThreadAwareChatHistoryAgent;
+exports.processMessageWithHistory = processMessageWithHistory;
+const chatHistoryMessageModifier_1 = require("./chatHistoryMessageModifier");
+const unified_1 = require("@codebolt/agent/unified");
+// Example 1: Basic chat history integration
+function createBasicChatHistoryAgent() {
+    return new unified_1.InitialPromptGenerator({
+        processors: [
+            // Add chat history before other processors
+            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
+                enableChatHistory: true,
+                maxHistoryMessages: 5,
+                includeTimestamps: true,
+                compactFormat: false
+            }),
+            // ... other processors like system prompts, tools, etc.
+        ],
+        baseSystemPrompt: "You are a helpful assistant."
+    });
+}
+// Example 2: Compact chat history for token efficiency
+function createCompactChatHistoryAgent() {
+    return new unified_1.InitialPromptGenerator({
+        processors: [
+            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
+                enableChatHistory: true,
+                maxHistoryMessages: 10,
+                includeTimestamps: false,
+                compactFormat: true,
+                includeSystemMessages: false,
+                historyContextLabel: "Previous Conversation"
+            }),
+        ],
+        baseSystemPrompt: "You are a helpful assistant."
+    });
+}
+// Example 3: Thread-specific chat history (when API supports it)
+function createThreadAwareChatHistoryAgent() {
+    return new unified_1.InitialPromptGenerator({
+        processors: [
+            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
+                enableChatHistory: true,
+                maxHistoryMessages: 8,
+                filterByThreadId: true, // Filter by thread ID when supported
+                includeTimestamps: true,
+                compactFormat: false,
+                historyContextLabel: "Thread History"
+            }),
+        ],
+        baseSystemPrompt: "You are a helpful assistant."
+    });
+}
+// Example 4: Usage in a real agent scenario
+async function processMessageWithHistory(userMessage) {
+    const promptGenerator = new unified_1.InitialPromptGenerator({
+        processors: [
+            // Chat history comes first to provide context
+            new chatHistoryMessageModifier_1.ChatHistoryMessageModifier({
+                enableChatHistory: true,
+                maxHistoryMessages: 5,
+                includeTimestamps: false,
+                compactFormat: true
+            }),
+            // Add other processors after history
+            // new EnvironmentContextModifier(),
+            // new CoreSystemPromptModifier({ systemPrompt: "..." }),
+            // new ToolInjectionModifier(),
+        ],
+        baseSystemPrompt: "You are a helpful AI assistant."
+    });
+    try {
+        const processedMessage = await promptGenerator.processMessage(userMessage);
+        console.log('Message processed with chat history context');
+        return processedMessage;
+    }
+    catch (error) {
+        console.error('Error processing message with history:', error);
+        throw error;
+    }
+}
+// Example 5: Configuration options explained
+exports.chatHistoryOptions = {
+    // Enable/disable chat history entirely
+    enableChatHistory: true,
+    // Maximum number of previous messages to include
+    maxHistoryMessages: 10,
+    // Include system messages in history
+    includeSystemMessages: false,
+    // Custom label for the history section
+    historyContextLabel: "Previous Conversation",
+    // Filter by thread ID (when API supports it)
+    filterByThreadId: true,
+    // Include timestamps with messages
+    includeTimestamps: true,
+    // Use compact format to save tokens
+    compactFormat: false
+};
+// Example output format:
+/*
+=== Chat History ===
+Thread ID: 6536c82f-c7d1-4dbd-8e68-c90f7ef5ebc3
+Recent 3 messages:
+
+**User (2025-01-15 10:30:15):**
+Can you help me with my React component?
+
+**Assistant (2025-01-15 10:30:45):**
+Of course! I'd be happy to help you with your React component. Could you please share the code or describe what specific issue you're facing?
+
+**User (2025-01-15 10:31:20):**
+I'm having trouble with state management in my component.
+
+=== End Chat History ===
+*/

package/dist/processor-pieces/messageModifiers/environmentContext.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export interface Part {
+    text: string;
+}
+export interface EnvironmentContextOptions {
+    workspaceDirectories: string[];
+    includeFullContext?: boolean;
+    maxItems?: number;
+    ignoredFolders?: Set<string>;
+    fileIncludePattern?: RegExp;
+    respectGitIgnore?: boolean;
+    respectGeminiIgnore?: boolean;
+}
+export interface FolderStructureOptions {
+    maxItems?: number;
+    ignoredFolders?: Set<string>;
+    fileIncludePattern?: RegExp;
+    respectGitIgnore?: boolean;
+    respectGeminiIgnore?: boolean;
+}
+/**
+ * Standalone version of getFolderStructure
+ */
+export declare function getFolderStructure(targetPath: string, options?: FolderStructureOptions): Promise<string>;
+/**
+ * Standalone version of getDirectoryContextString
+ */
+export declare function getDirectoryContextString(workspaceDirectories: string[], options?: FolderStructureOptions): Promise<string>;
+/**
+ * Standalone version of getEnvironmentContext
+ */
+export declare function getEnvironmentContext(options: EnvironmentContextOptions): Promise<Part[]>;
+/**
+ * Utility function to read multiple files (basic implementation for full context)
+ * This is a simplified version - extend as needed for your use case
+ */
+export declare function readMultipleFiles(basePath: string, patterns?: string[], options?: FolderStructureOptions): Promise<string>;

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

@@ -0,0 +1,355 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderStructure = getFolderStructure;
+exports.getDirectoryContextString = getDirectoryContextString;
+exports.getEnvironmentContext = getEnvironmentContext;
+exports.readMultipleFiles = readMultipleFiles;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const MAX_ITEMS = 200;
+const DEFAULT_IGNORED_FOLDERS = new Set(['node_modules', '.git', 'dist']);
+/**
+ * Simple gitignore pattern matcher (basic implementation)
+ * For production use, consider using a dedicated gitignore library
+ */
+function shouldIgnoreFile(filePath, options) {
+    if (!options.respectGitIgnore && !options.respectGeminiIgnore) {
+        return false;
+    }
+    // Basic ignore patterns - in production, you'd want to read actual .gitignore/.geminiignore files
+    const commonIgnorePatterns = [
+        /node_modules/,
+        /\.git/,
+        /dist/,
+        /build/,
+        /\.DS_Store/,
+        /\.env/,
+        /\.log$/,
+        /\.tmp$/,
+        /\.cache/
+    ];
+    return commonIgnorePatterns.some(pattern => pattern.test(filePath));
+}
+/**
+ * Reads the full folder structure recursively
+ */
+async function 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;
+    const processedPaths = new Set();
+    while (queue.length > 0) {
+        const { folderInfo, currentPath } = queue.shift();
+        if (processedPaths.has(currentPath)) {
+            continue;
+        }
+        processedPaths.add(currentPath);
+        if (currentItemCount >= options.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 >= options.maxItems) {
+                    folderInfo.hasMoreFiles = true;
+                    break;
+                }
+                const fileName = entry.name;
+                const filePath = path.join(currentPath, fileName);
+                if (shouldIgnoreFile(filePath, options)) {
+                    continue;
+                }
+                if (!options.fileIncludePattern || options.fileIncludePattern.test(fileName)) {
+                    filesInCurrentDir.push(fileName);
+                    currentItemCount++;
+                    folderInfo.totalFiles++;
+                    folderInfo.totalChildren++;
+                }
+            }
+        }
+        folderInfo.files = filesInCurrentDir;
+        // Process directories
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (currentItemCount >= options.maxItems) {
+                    folderInfo.hasMoreSubfolders = true;
+                    break;
+                }
+                const subFolderName = entry.name;
+                const subFolderPath = path.join(currentPath, subFolderName);
+                if (options.ignoredFolders.has(subFolderName) || shouldIgnoreFile(subFolderPath, options)) {
+                    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;
+}
+/**
+ * Formats a folder structure into a readable string representation
+ */
+function formatFolderStructure(folderInfo, prefix = '', isLast = true) {
+    const connector = isLast ? '└── ' : '├── ';
+    const extension = isLast ? '    ' : '│   ';
+    let result = `${prefix}${connector}${folderInfo.name}`;
+    if (folderInfo.isIgnored) {
+        result += ' (ignored)';
+    }
+    result += '\n';
+    // Add files
+    const allFiles = [...folderInfo.files];
+    if (folderInfo.hasMoreFiles) {
+        allFiles.push('...');
+    }
+    allFiles.forEach((file, index) => {
+        const isLastFile = index === allFiles.length - 1 && folderInfo.subFolders.length === 0;
+        const fileConnector = isLastFile ? '└── ' : '├── ';
+        result += `${prefix}${extension}${fileConnector}${file}\n`;
+    });
+    // Add subfolders
+    folderInfo.subFolders.forEach((subFolder, index) => {
+        const isLastSubFolder = index === folderInfo.subFolders.length - 1;
+        result += formatFolderStructure(subFolder, prefix + extension, isLastSubFolder);
+    });
+    if (folderInfo.hasMoreSubfolders) {
+        const moreConnector = '└── ';
+        result += `${prefix}${extension}${moreConnector}...\n`;
+    }
+    return result;
+}
+/**
+ * Standalone version of getFolderStructure
+ */
+async function getFolderStructure(targetPath, options = {}) {
+    var _a, _b, _c, _d, _e;
+    const mergedOptions = {
+        maxItems: (_a = options.maxItems) !== null && _a !== void 0 ? _a : MAX_ITEMS,
+        ignoredFolders: (_b = options.ignoredFolders) !== null && _b !== void 0 ? _b : DEFAULT_IGNORED_FOLDERS,
+        fileIncludePattern: (_c = options.fileIncludePattern) !== null && _c !== void 0 ? _c : /.*/,
+        respectGitIgnore: (_d = options.respectGitIgnore) !== null && _d !== void 0 ? _d : true,
+        respectGeminiIgnore: (_e = options.respectGeminiIgnore) !== null && _e !== void 0 ? _e : true,
+    };
+    try {
+        const folderInfo = await readFullStructure(targetPath, mergedOptions);
+        if (!folderInfo) {
+            return `Error: Directory not found or inaccessible: ${targetPath}`;
+        }
+        return formatFolderStructure(folderInfo).trim();
+    }
+    catch (error) {
+        return `Error reading folder structure: ${error.message}`;
+    }
+}
+/**
+ * Standalone version of getDirectoryContextString
+ */
+async function getDirectoryContextString(workspaceDirectories, options = {}) {
+    const folderStructures = await Promise.all(workspaceDirectories.map((dir) => getFolderStructure(dir, options)));
+    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}`;
+    }
+    return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+}
+/**
+ * Standalone version of getEnvironmentContext
+ */
+async function getEnvironmentContext(options) {
+    const today = new Date().toLocaleDateString(undefined, {
+        weekday: 'long',
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+    });
+    const platform = process.platform;
+    const directoryContext = await getDirectoryContextString(options.workspaceDirectories, {
+        maxItems: options.maxItems,
+        ignoredFolders: options.ignoredFolders,
+        fileIncludePattern: options.fileIncludePattern,
+        respectGitIgnore: options.respectGitIgnore,
+        respectGeminiIgnore: options.respectGeminiIgnore,
+    });
+    const context = `
+This is the Gemini CLI. We are setting up the context for our chat.
+Today's date is ${today}.
+My operating system is: ${platform}
+${directoryContext}
+        `.trim();
+    const initialParts = [{ text: context }];
+    // Add full file context if requested
+    if (options.includeFullContext) {
+        try {
+            // This is a simplified version - in the original, this would use read_many_files tool
+            // For standalone use, you might want to implement your own file reading logic
+            const fullContextNote = `
+--- Full File Context (Standalone Version) ---
+Note: Full file context reading would require implementing file reading logic
+based on your specific needs. The original implementation uses the read_many_files tool
+from the Gemini CLI tool registry.
+`;
+            initialParts.push({ text: fullContextNote });
+        }
+        catch (error) {
+            console.error('Error reading full file context:', error);
+            initialParts.push({
+                text: '\n--- Error reading full file context ---',
+            });
+        }
+    }
+    return initialParts;
+}
+/**
+ * Utility function to read multiple files (basic implementation for full context)
+ * This is a simplified version - extend as needed for your use case
+ */
+async function readMultipleFiles(basePath, patterns = ['**/*'], options = {}) {
+    // This is a basic implementation - for production use, consider using a glob library
+    // like 'glob' or 'fast-glob' for pattern matching
+    try {
+        const files = [];
+        async function collectFiles(dirPath, currentDepth = 0) {
+            var _a;
+            if (currentDepth > 10)
+                return; // Prevent infinite recursion
+            try {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (shouldIgnoreFile(fullPath, options)) {
+                        continue;
+                    }
+                    if (entry.isFile()) {
+                        files.push(fullPath);
+                    }
+                    else if (entry.isDirectory() && !((_a = options.ignoredFolders) === null || _a === void 0 ? void 0 : _a.has(entry.name))) {
+                        await collectFiles(fullPath, currentDepth + 1);
+                    }
+                }
+            }
+            catch (error) {
+                // Skip directories we can't read
+                console.warn(`Warning: Could not read directory ${dirPath}: ${error.message}`);
+            }
+        }
+        await collectFiles(basePath);
+        // Read file contents (limit to reasonable size)
+        const fileContents = [];
+        for (const filePath of files.slice(0, 100)) { // Limit to first 100 files
+            try {
+                const stats = await fs.stat(filePath);
+                if (stats.size > 100 * 1024) { // Skip files larger than 100KB
+                    fileContents.push(`${filePath}: [File too large, skipped]`);
+                    continue;
+                }
+                const content = await fs.readFile(filePath, 'utf-8');
+                const relativePath = path.relative(basePath, filePath);
+                fileContents.push(`--- ${relativePath} ---\n${content}\n`);
+            }
+            catch (error) {
+                fileContents.push(`${filePath}: [Error reading file: ${error.message}]`);
+            }
+        }
+        return fileContents.join('\n');
+    }
+    catch (error) {
+        return `Error reading multiple files: ${error.message}`;
+    }
+}

package/dist/processor-pieces/messageModifiers/handleUrlMessageModifier.d.ts

@@ -1,4 +1,5 @@
-import { BaseMessageModifier, MessageModifierInput, ProcessedMessage } from '../../processor';
+import { FlatUserMessage } from '@codebolt/types/sdk';
+import { BaseMessageModifier, ProcessedMessage } from '../../processor';
 export interface HandleUrlMessageModifierOptions {
     googleSearchEnabled?: boolean;
     fetchUrlContent?: boolean;
@@ -7,6 +8,6 @@ export declare class HandleUrlMessageModifier extends BaseMessageModifier {
     private readonly googleSearchEnabled;
     private readonly fetchUrlContent;
     constructor(options?: HandleUrlMessageModifierOptions);
-    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
     private extractUrls;
 }

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

@@ -8,9 +8,8 @@ class HandleUrlMessageModifier extends processor_1.BaseMessageModifier {
         this.googleSearchEnabled = options.googleSearchEnabled || false;
         this.fetchUrlContent = options.fetchUrlContent || false;
     }
-    async modify(input) {
+    async modify(originalRequest, createdMessage) {
         try {
-            const { originalRequest, createdMessage, context } = input;
             // Check if the request contains URLs
             const urls = this.extractUrls(originalRequest);
             if (urls.length > 0) {