@codebolt/agent 5.0.1 → 5.0.6

package/dist/local-tools/fileTools.js

@@ -1,162 +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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileCopyTool = exports.FileMoveTool = exports.FileDeleteTool = exports.FileWriteTool = exports.FileReadTool = void 0;
-const processor_1 = require("../processor");
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-class FileReadTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileRead', 'Read content from a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to read' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath is required');
-        }
-        const { filePath } = params;
-        const content = await fs.readFile(filePath, 'utf-8');
-        return content;
-    }
-    validateParameters(params) {
-        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
-    }
-}
-exports.FileReadTool = FileReadTool;
-class FileWriteTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileWrite', 'Write content to a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to write' },
-            content: { type: 'string', required: true, description: 'Content to write to the file' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath and content are required');
-        }
-        const { filePath, content } = params;
-        // Ensure directory exists
-        const dir = path.dirname(filePath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(filePath, content, 'utf-8');
-        return `Successfully wrote ${content.length} characters to ${filePath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.filePath === 'string' &&
-            params.filePath.trim() !== '' &&
-            typeof params.content === 'string';
-    }
-}
-exports.FileWriteTool = FileWriteTool;
-class FileDeleteTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileDelete', 'Delete a file', {
-            filePath: { type: 'string', required: true, description: 'Path to the file to delete' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: filePath is required');
-        }
-        const { filePath } = params;
-        await fs.unlink(filePath);
-        return `Successfully deleted ${filePath}`;
-    }
-    validateParameters(params) {
-        return params && typeof params.filePath === 'string' && params.filePath.trim() !== '';
-    }
-}
-exports.FileDeleteTool = FileDeleteTool;
-class FileMoveTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileMove', 'Move a file from one location to another', {
-            sourcePath: { type: 'string', required: true, description: 'Source file path' },
-            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
-        }
-        const { sourcePath, destinationPath } = params;
-        // Ensure destination directory exists
-        const dir = path.dirname(destinationPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.rename(sourcePath, destinationPath);
-        return `Successfully moved ${sourcePath} to ${destinationPath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.sourcePath === 'string' &&
-            params.sourcePath.trim() !== '' &&
-            typeof params.destinationPath === 'string' &&
-            params.destinationPath.trim() !== '';
-    }
-}
-exports.FileMoveTool = FileMoveTool;
-class FileCopyTool extends processor_1.BaseTool {
-    constructor() {
-        super('FileCopy', 'Copy a file from one location to another', {
-            sourcePath: { type: 'string', required: true, description: 'Source file path' },
-            destinationPath: { type: 'string', required: true, description: 'Destination file path' }
-        });
-    }
-    async execute(params, abortSignal) {
-        await this.checkAbortSignal(abortSignal);
-        if (!this.validateParameters(params)) {
-            throw new Error('Invalid parameters: sourcePath and destinationPath are required');
-        }
-        const { sourcePath, destinationPath } = params;
-        // Ensure destination directory exists
-        const dir = path.dirname(destinationPath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.copyFile(sourcePath, destinationPath);
-        return `Successfully copied ${sourcePath} to ${destinationPath}`;
-    }
-    validateParameters(params) {
-        return params &&
-            typeof params.sourcePath === 'string' &&
-            params.sourcePath.trim() !== '' &&
-            typeof params.destinationPath === 'string' &&
-            params.destinationPath.trim() !== '';
-    }
-}
-exports.FileCopyTool = FileCopyTool;

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

@@ -1,13 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ArgumentProcessorOptions {
-    appendRawInvocation?: boolean;
-    argumentSeparator?: string;
-    includeCommandName?: boolean;
-}
-export declare class ArgumentProcessorModifier extends BaseMessageModifier {
-    private readonly options;
-    constructor(options?: ArgumentProcessorOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-}

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

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArgumentProcessorModifier = void 0;
-const base_1 = require("../base");
-class ArgumentProcessorModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = {
-            appendRawInvocation: options.appendRawInvocation !== false,
-            argumentSeparator: options.argumentSeparator || ' ',
-            includeCommandName: options.includeCommandName || false
-        };
-    }
-    modify(originalRequest, createdMessage) {
-        var _a;
-        try {
-            // Get arguments from metadata
-            const invocation = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.invocation;
-            if (!(invocation === null || invocation === void 0 ? void 0 : invocation.args)) {
-                return Promise.resolve(createdMessage);
-            }
-            // Find the user message to append arguments to
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
-            if (!userMessage || typeof userMessage.content !== 'string') {
-                return Promise.resolve(createdMessage);
-            }
-            let appendContent = '';
-            if (this.options.appendRawInvocation && invocation.raw) {
-                // Append the full raw command invocation
-                appendContent = `\n\nFull command: ${invocation.raw}`;
-            }
-            else {
-                // Append just the arguments
-                let argsToAppend = invocation.args;
-                if (this.options.includeCommandName && invocation.name) {
-                    argsToAppend = `${invocation.name}${this.options.argumentSeparator}${argsToAppend}`;
-                }
-                appendContent = `\n\nArguments: ${argsToAppend}`;
-            }
-            // Update the user message with appended arguments
-            const updatedMessages = createdMessage.message.messages.map(msg => {
-                if (msg.role === 'user' && typeof msg.content === 'string' && msg === userMessage) {
-                    return {
-                        ...msg,
-                        content: msg.content + appendContent
-                    };
-                }
-                return msg;
-            });
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages: updatedMessages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    argumentsProcessed: true,
-                    argumentsAppended: appendContent.trim()
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in ArgumentProcessorModifier:', error);
-            return Promise.resolve(createdMessage);
-        }
-    }
-}
-exports.ArgumentProcessorModifier = ArgumentProcessorModifier;

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

@@ -1,15 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface AtFileProcessorOptions {
-    maxFileSize?: number;
-    allowedExtensions?: string[];
-    basePath?: string;
-}
-export declare class AtFileProcessorModifier extends BaseMessageModifier {
-    private readonly options;
-    constructor(options?: AtFileProcessorOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private readFileContent;
-    private getFolderStructure;
-}

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

@@ -1,212 +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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtFileProcessorModifier = void 0;
-const base_1 = require("../base");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-class AtFileProcessorModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = {
-            maxFileSize: options.maxFileSize || 1024 * 1024, // 1MB default
-            allowedExtensions: options.allowedExtensions || ['.ts', '.js', '.json', '.md', '.txt', '.yml', '.yaml', '.xml', '.html', '.css', '.py', '.java', '.cpp', '.c', '.h'],
-            basePath: options.basePath || process.cwd()
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            const mentionedFiles = originalRequest.mentionedFiles || [];
-            const mentionedFolders = originalRequest.mentionedFolders || [];
-            if (mentionedFiles.length === 0 && mentionedFolders.length === 0) {
-                return createdMessage;
-            }
-            const contextParts = [];
-            // Process mentioned files
-            if (mentionedFiles.length > 0) {
-                const fileContents = await Promise.all(mentionedFiles.map(async (filePath) => {
-                    try {
-                        const content = await this.readFileContent(filePath);
-                        return `--- Content from ${filePath} ---\n${content}\n--- End of ${filePath} ---`;
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                        return `[Error loading ${filePath}: ${errorMessage}]`;
-                    }
-                }));
-                contextParts.push(`File Contents:\n${fileContents.join('\n\n')}`);
-            }
-            // Process mentioned folders
-            if (mentionedFolders.length > 0) {
-                const folderContents = await Promise.all(mentionedFolders.map(async (folderPath) => {
-                    try {
-                        const structure = await this.getFolderStructure(folderPath);
-                        return `--- Structure of ${folderPath} ---\n${structure}\n--- End of ${folderPath} ---`;
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                        return `[Error reading folder ${folderPath}: ${errorMessage}]`;
-                    }
-                }));
-                contextParts.push(`Folder Structures:\n${folderContents.join('\n\n')}`);
-            }
-            // Find the last user message and append context to it
-            const messages = [...createdMessage.message.messages];
-            let lastUserMessageIndex = -1;
-            for (let i = messages.length - 1; i >= 0; i--) {
-                if (messages[i].role === 'user') {
-                    lastUserMessageIndex = i;
-                    break;
-                }
-            }
-            if (lastUserMessageIndex !== -1) {
-                const lastUserMessage = messages[lastUserMessageIndex];
-                const currentContent = Array.isArray(lastUserMessage.content)
-                    ? lastUserMessage.content
-                    : [{ type: 'text', text: lastUserMessage.content }];
-                // Add context as additional content parts
-                const contextContent = {
-                    type: 'text',
-                    text: contextParts.join('\n\n')
-                };
-                messages[lastUserMessageIndex] = {
-                    ...lastUserMessage,
-                    content: [...currentContent, contextContent]
-                };
-            }
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    atFileProcessed: true,
-                    processedFiles: mentionedFiles,
-                    processedFolders: mentionedFolders
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in AtFileProcessorModifier:', error);
-            return createdMessage;
-        }
-    }
-    async readFileContent(filePath) {
-        // Resolve path relative to base path
-        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(this.options.basePath, filePath);
-        // Security check: ensure the file is within allowed directory
-        const relativePath = path.relative(this.options.basePath, resolvedPath);
-        if (relativePath.startsWith('..')) {
-            throw new Error(`Access denied: ${filePath} is outside the allowed directory`);
-        }
-        // Check if file exists
-        try {
-            await fs.promises.access(resolvedPath, fs.constants.R_OK);
-        }
-        catch (error) {
-            throw new Error(`File not found or not readable: ${filePath}`);
-        }
-        // Check file size
-        const stats = await fs.promises.stat(resolvedPath);
-        if (stats.size > this.options.maxFileSize) {
-            throw new Error(`File too large: ${filePath} (${stats.size} bytes, max ${this.options.maxFileSize} bytes)`);
-        }
-        // Check file extension if allowedExtensions is specified
-        if (this.options.allowedExtensions.length > 0) {
-            const ext = path.extname(resolvedPath).toLowerCase();
-            if (!this.options.allowedExtensions.includes(ext)) {
-                throw new Error(`File type not allowed: ${ext}`);
-            }
-        }
-        // Read and return file content
-        const content = await fs.promises.readFile(resolvedPath, 'utf-8');
-        return content;
-    }
-    async getFolderStructure(folderPath) {
-        // Resolve path relative to base path
-        const resolvedPath = path.isAbsolute(folderPath) ? folderPath : path.resolve(this.options.basePath, folderPath);
-        // Security check: ensure the folder is within allowed directory
-        const relativePath = path.relative(this.options.basePath, resolvedPath);
-        if (relativePath.startsWith('..')) {
-            throw new Error(`Access denied: ${folderPath} is outside the allowed directory`);
-        }
-        // Check if folder exists and is readable
-        try {
-            await fs.promises.access(resolvedPath, fs.constants.R_OK);
-            const stats = await fs.promises.stat(resolvedPath);
-            if (!stats.isDirectory()) {
-                throw new Error(`${folderPath} is not a directory`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Folder not found or not readable: ${folderPath}`);
-        }
-        // Read directory structure
-        try {
-            const entries = await fs.promises.readdir(resolvedPath, { withFileTypes: true });
-            const lines = [];
-            // Sort entries: directories first, then files
-            const sortedEntries = entries.sort((a, b) => {
-                if (a.isDirectory() && !b.isDirectory())
-                    return -1;
-                if (!a.isDirectory() && b.isDirectory())
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            for (const entry of sortedEntries.slice(0, 50)) { // Limit to 50 entries
-                if (entry.name.startsWith('.'))
-                    continue; // Skip hidden files
-                if (entry.isDirectory()) {
-                    lines.push(`${folderPath}/${entry.name}/`);
-                }
-                else {
-                    const filePath = path.join(resolvedPath, entry.name);
-                    const stats = await fs.promises.stat(filePath);
-                    const size = stats.size < 1024 ? `${stats.size}B` : `${Math.round(stats.size / 1024)}KB`;
-                    lines.push(`${folderPath}/${entry.name} (${size})`);
-                }
-            }
-            if (entries.length > 50) {
-                lines.push(`... and ${entries.length - 50} more items`);
-            }
-            return lines.join('\n');
-        }
-        catch (error) {
-            throw new Error(`Error reading folder structure: ${error instanceof Error ? error.message : 'unknown error'}`);
-        }
-    }
-}
-exports.AtFileProcessorModifier = AtFileProcessorModifier;

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

@@ -1,19 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ChatCompressionOptions {
-    tokenThreshold?: number;
-    compressionRatio?: number;
-    preserveRecentMessages?: number;
-    enableCompression?: boolean;
-}
-export declare class ChatCompressionModifier extends BaseMessageModifier {
-    private readonly options;
-    private hasFailedCompressionAttempt;
-    constructor(options?: ChatCompressionOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private shouldCompressChat;
-    private compressMessages;
-    private createConversationSummary;
-    resetCompressionState(): void;
-}

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

@@ -1,110 +0,0 @@
-"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/additionalModifiers/chatRecordingModifier.d.ts

@@ -1,23 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ChatRecordingOptions {
-    enableRecording?: boolean;
-    recordingPath?: string;
-    maxRecordingSize?: number;
-    includeMetadata?: boolean;
-    recordingFormat?: 'json' | 'markdown';
-}
-export declare class ChatRecordingModifier extends BaseMessageModifier {
-    private readonly options;
-    private recordingFile?;
-    constructor(options?: ChatRecordingOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private initializeRecording;
-    private recordMessages;
-    private writeRecord;
-    startRecording(customPath?: string): void;
-    stopRecording(): void;
-    getRecordingFile(): string | undefined;
-    isRecording(): boolean;
-}