@codebolt/agent 1.2.1 → 2.2.3

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.d.ts

@@ -0,0 +1,18 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface ChatHistoryMessageModifierOptions {
+    enableChatHistory?: boolean;
+    maxHistoryMessages?: number;
+    includeSystemMessages?: boolean;
+    [key: string]: unknown;
+}
+export declare class ChatHistoryMessageModifier extends BaseMessageModifier {
+    private readonly enableChatHistory;
+    private readonly maxHistoryMessages;
+    private readonly includeSystemMessages;
+    constructor(options?: ChatHistoryMessageModifierOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getChatHistory;
+    setMaxHistoryMessages(max: number): void;
+}

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/chatHistoryMessageModifier.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatHistoryMessageModifier = void 0;
+const base_1 = require("../base");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+// Using MessageObject from SDK types for chat history messages
+class ChatHistoryMessageModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super({ context: options });
+        this.enableChatHistory = options.enableChatHistory !== false;
+        this.maxHistoryMessages = options.maxHistoryMessages || 20;
+        this.includeSystemMessages = options.includeSystemMessages !== false;
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.enableChatHistory) {
+                return createdMessage;
+            }
+            // Get chat history using the thread ID from the original request
+            const chatHistory = await this.getChatHistory(originalRequest.threadId);
+            if (!chatHistory || chatHistory.length === 0) {
+                return createdMessage;
+            }
+            // Directly use the chat history messages - they're already in MessageObject format
+            return {
+                message: {
+                    ...createdMessage.message,
+                    messages: [...chatHistory, ...createdMessage.message.messages]
+                },
+                metadata: {
+                    ...createdMessage.metadata,
+                    chatHistoryAdded: true,
+                    chatHistoryCount: chatHistory.length,
+                    threadId: originalRequest.threadId
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in ChatHistoryMessageModifier:', error);
+            // Return original message if chat history fails to avoid breaking the flow
+            return createdMessage;
+        }
+    }
+    async getChatHistory(threadId) {
+        var _a, _b, _c, _d;
+        try {
+            const response = await codeboltjs_1.default.chat.getChatHistory(threadId);
+            // Check if response has messages array
+            if (!(response === null || response === void 0 ? void 0 : response.chats) || !((_a = response === null || response === void 0 ? void 0 : response.chats) === null || _a === void 0 ? void 0 : _a.messages) || !Array.isArray((_b = response === null || response === void 0 ? void 0 : response.chats) === null || _b === void 0 ? void 0 : _b.messages) || ((_c = response === null || response === void 0 ? void 0 : response.chats) === null || _c === void 0 ? void 0 : _c.messages.length) === 0) {
+                return [];
+            }
+            let historyMessages = (_d = response === null || response === void 0 ? void 0 : response.chats) === null || _d === void 0 ? void 0 : _d.messages;
+            // Thread filtering is now handled by the API directly via threadId parameter
+            // Filter out system messages if not included
+            if (!this.includeSystemMessages) {
+                historyMessages = historyMessages.filter((msg) => msg.role !== 'system');
+            }
+            // Limit the number of messages
+            // will do it later
+            if (false) {
+                historyMessages = historyMessages.slice(-this.maxHistoryMessages);
+            }
+            // Check if the last message is an assistant message with tool_calls
+            // If so, add tool response messages for each tool_call
+            const lastMessage = historyMessages[historyMessages.length - 1];
+            if (lastMessage &&
+                lastMessage.role === 'assistant' &&
+                lastMessage.tool_calls &&
+                Array.isArray(lastMessage.tool_calls) &&
+                lastMessage.tool_calls.length > 0) {
+                // Add tool response messages for each tool_call
+                const toolResponseMessages = [];
+                for (const toolCall of lastMessage.tool_calls) {
+                    toolResponseMessages.push({
+                        role: 'tool',
+                        content: `Tool call "${toolCall.function.name}" was not executed. This appears to be from a previous incomplete conversation. The tool was called with arguments: ${toolCall.function.arguments}`,
+                        tool_call_id: toolCall.id
+                    });
+                }
+                // Return original messages + tool responses + context message
+                return [...historyMessages, ...toolResponseMessages];
+            }
+            // Add a system message to indicate this is previous conversation
+            const contextMessage = {
+                role: 'user',
+                content: '--- End of previous conversation history ---\n\nThe above messages are from a previous conversation. Any incomplete tool calls have been marked as not executed. You should now respond to the current user message.'
+            };
+            historyMessages = [...historyMessages, contextMessage];
+            // Return messages as-is if no tool_calls in last message
+            return historyMessages;
+        }
+        catch (error) {
+            console.error('Error retrieving chat history:', error);
+            return [];
+        }
+    }
+    setMaxHistoryMessages(max) {
+        this.maxHistoryMessages = max;
+    }
+}
+exports.ChatHistoryMessageModifier = ChatHistoryMessageModifier;

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

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

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

@@ -0,0 +1,173 @@
+"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.ChatRecordingModifier = void 0;
+const base_1 = require("../base");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ChatRecordingModifier extends base_1.BaseMessageModifier {
+    constructor(options = {}) {
+        super();
+        this.options = {
+            enableRecording: options.enableRecording || false,
+            recordingPath: options.recordingPath || path.join(process.cwd(), '.chat-recordings'),
+            maxRecordingSize: options.maxRecordingSize || 10 * 1024 * 1024, // 10MB
+            includeMetadata: options.includeMetadata !== false,
+            recordingFormat: options.recordingFormat || 'json'
+        };
+        if (this.options.enableRecording) {
+            this.initializeRecording();
+        }
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            if (!this.options.enableRecording || !this.recordingFile) {
+                return createdMessage;
+            }
+            // Record the conversation
+            await this.recordMessages(createdMessage, originalRequest);
+            return Promise.resolve({
+                ...createdMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    chatRecorded: true,
+                    recordingFile: this.recordingFile
+                }
+            });
+        }
+        catch (error) {
+            console.error('Error in ChatRecordingModifier:', error);
+            return createdMessage;
+        }
+    }
+    initializeRecording() {
+        try {
+            // Ensure recording directory exists
+            if (!fs.existsSync(this.options.recordingPath)) {
+                fs.mkdirSync(this.options.recordingPath, { recursive: true });
+            }
+            // Create recording file with timestamp
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const extension = this.options.recordingFormat === 'markdown' ? 'md' : 'jsonl';
+            this.recordingFile = path.join(this.options.recordingPath, `chat-${timestamp}.${extension}`);
+            // Initialize file with header
+            if (this.options.recordingFormat === 'markdown') {
+                fs.writeFileSync(this.recordingFile, `# Chat Recording\n\nStarted: ${new Date().toISOString()}\n\n---\n\n`);
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize chat recording:', error);
+            this.recordingFile = undefined;
+        }
+    }
+    async recordMessages(createdMessage, originalRequest) {
+        var _a, _b;
+        if (!this.recordingFile)
+            return;
+        try {
+            // Check file size before writing
+            if (fs.existsSync(this.recordingFile)) {
+                const stats = fs.statSync(this.recordingFile);
+                if (stats.size > this.options.maxRecordingSize) {
+                    console.warn(`Chat recording file ${this.recordingFile} exceeds maximum size. Stopping recording.`);
+                    return;
+                }
+            }
+            const timestamp = new Date().toISOString();
+            // Record each message
+            for (const message of createdMessage.message.messages) {
+                const record = {
+                    timestamp,
+                    messageId: (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.messageId,
+                    threadId: (_b = createdMessage.metadata) === null || _b === void 0 ? void 0 : _b.threadId,
+                    role: message.role,
+                    content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
+                };
+                if (this.options.includeMetadata) {
+                    record.metadata = {
+                        originalRequest: {
+                            userMessage: originalRequest.userMessage,
+                            messageId: originalRequest.messageId,
+                            threadId: originalRequest.threadId
+                        },
+                        processedMetadata: createdMessage.metadata
+                    };
+                }
+                await this.writeRecord(record);
+            }
+        }
+        catch (error) {
+            console.error('Error recording chat messages:', error);
+        }
+    }
+    async writeRecord(record) {
+        if (!this.recordingFile)
+            return;
+        try {
+            if (this.options.recordingFormat === 'markdown') {
+                const content = `## ${record.role.toUpperCase()} - ${record.timestamp}\n\n${record.content}\n\n---\n\n`;
+                fs.appendFileSync(this.recordingFile, content);
+            }
+            else {
+                const jsonLine = JSON.stringify(record) + '\n';
+                fs.appendFileSync(this.recordingFile, jsonLine);
+            }
+        }
+        catch (error) {
+            console.error('Error writing chat record:', error);
+        }
+    }
+    startRecording(customPath) {
+        this.options.enableRecording = true;
+        if (customPath) {
+            this.options.recordingPath = customPath;
+        }
+        this.initializeRecording();
+    }
+    stopRecording() {
+        this.options.enableRecording = false;
+        if (this.recordingFile && this.options.recordingFormat === 'markdown') {
+            fs.appendFileSync(this.recordingFile, `\n---\n\nRecording ended: ${new Date().toISOString()}\n`);
+        }
+        this.recordingFile = undefined;
+    }
+    getRecordingFile() {
+        return this.recordingFile;
+    }
+    isRecording() {
+        return (this.options.enableRecording || false) && !!this.recordingFile;
+    }
+}
+exports.ChatRecordingModifier = ChatRecordingModifier;

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

@@ -0,0 +1,14 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BaseMessageModifier } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export interface CoreSystemPromptOptions {
+    customSystemPrompt?: string;
+    userMemory?: string;
+}
+export declare class CoreSystemPromptModifier extends BaseMessageModifier {
+    private readonly options;
+    constructor(options?: CoreSystemPromptOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    private getCoreSystemPrompt;
+    private getDefaultSystemPrompt;
+}