@codebolt/agent 1.2.1 → 2.2.3

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionModifier = exports.CompressionStatus = void 0;
+const base_1 = require("../base");
+/**
+ * Threshold for compression token count as a fraction of the model's token limit.
+ * If the chat history exceeds this threshold, it will be compressed.
+ */
+const COMPRESSION_TOKEN_THRESHOLD = 0.7;
+/**
+ * The fraction of the latest chat history to keep. A value of 0.3
+ * means that only the last 30% of the chat history will be kept after compression.
+ */
+const COMPRESSION_PRESERVE_THRESHOLD = 0.3;
+var CompressionStatus;
+(function (CompressionStatus) {
+    /** The compression was successful */
+    CompressionStatus[CompressionStatus["COMPRESSED"] = 1] = "COMPRESSED";
+    /** The compression failed due to the compression inflating the token count */
+    CompressionStatus[CompressionStatus["COMPRESSION_FAILED_INFLATED_TOKEN_COUNT"] = 2] = "COMPRESSION_FAILED_INFLATED_TOKEN_COUNT";
+    /** The compression failed due to an error counting tokens */
+    CompressionStatus[CompressionStatus["COMPRESSION_FAILED_TOKEN_COUNT_ERROR"] = 3] = "COMPRESSION_FAILED_TOKEN_COUNT_ERROR";
+    /** The compression was not necessary and no action was taken */
+    CompressionStatus[CompressionStatus["NOOP"] = 4] = "NOOP";
+})(CompressionStatus || (exports.CompressionStatus = CompressionStatus = {}));
+/**
+ * Returns the index of the content after the fraction of the total characters in the history.
+ */
+function findIndexAfterFraction(history, fraction) {
+    if (fraction <= 0 || fraction >= 1) {
+        throw new Error('Fraction must be between 0 and 1');
+    }
+    const contentLengths = history.map((content) => JSON.stringify(content).length);
+    const totalCharacters = contentLengths.reduce((sum, length) => sum + length, 0);
+    const targetCharacters = totalCharacters * fraction;
+    let charactersSoFar = 0;
+    for (let i = 0; i < contentLengths.length; i++) {
+        charactersSoFar += contentLengths[i];
+        if (charactersSoFar >= targetCharacters) {
+            return i;
+        }
+    }
+    return contentLengths.length;
+}
+function isFunctionResponse(message) {
+    // Check if message has function response content
+    if (typeof message.content === 'object' && message.content !== null) {
+        return 'functionResponse' in message.content;
+    }
+    return false;
+}
+// Mock token limit for different models (should be replaced with actual implementation)
+function tokenLimit(model) {
+    // Default token limits for common models
+    if (model.includes('gemini-pro'))
+        return 30720;
+    if (model.includes('gemini-flash'))
+        return 1048576;
+    if (model.includes('gpt-4'))
+        return 8192;
+    if (model.includes('gpt-3.5'))
+        return 4096;
+    return 8192; // Default fallback
+}
+class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
+    constructor(options = {}) {
+        super();
+        this.hasFailedCompressionAttempt = false;
+        this.options = {
+            contextPercentageThreshold: options.contextPercentageThreshold || COMPRESSION_TOKEN_THRESHOLD,
+            enableCompression: options.enableCompression !== false,
+            force: options.force || false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const compressionResult = await this.tryCompressChat(createdMessage.message.messages, this.options.force || false);
+            if (compressionResult.compressionStatus === CompressionStatus.COMPRESSED) {
+                return {
+                    message: {
+                        ...createdMessage.message,
+                        messages: compressionResult.compressedMessages || createdMessage.message.messages
+                    },
+                    metadata: {
+                        ...createdMessage.metadata,
+                        chatCompressed: true,
+                        originalTokenCount: compressionResult.originalTokenCount,
+                        newTokenCount: compressionResult.newTokenCount,
+                        compressionStatus: compressionResult.compressionStatus
+                    }
+                };
+            }
+            return {
+                ...createdMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    compressionStatus: compressionResult.compressionStatus,
+                    originalTokenCount: compressionResult.originalTokenCount,
+                    newTokenCount: compressionResult.newTokenCount
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionModifier:', error);
+            this.hasFailedCompressionAttempt = true;
+            return createdMessage;
+        }
+    }
+    async tryCompressChat(messages, force = false) {
+        var _a;
+        const curatedHistory = messages;
+        // Regardless of `force`, don't do anything if the history is empty.
+        if (curatedHistory.length === 0 ||
+            (this.hasFailedCompressionAttempt && !force)) {
+            return {
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.NOOP,
+            };
+        }
+        // Mock model - should be replaced with actual model detection
+        const model = "gemini-pro";
+        const originalTokenCount = await this.countTokens(model, curatedHistory);
+        if (originalTokenCount === undefined) {
+            console.warn(`Could not determine token count for model ${model}.`);
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR,
+            };
+        }
+        const contextPercentageThreshold = this.options.contextPercentageThreshold;
+        // Don't compress if not forced and we are under the limit.
+        if (!force) {
+            const threshold = contextPercentageThreshold !== null && contextPercentageThreshold !== void 0 ? contextPercentageThreshold : COMPRESSION_TOKEN_THRESHOLD;
+            if (originalTokenCount < threshold * tokenLimit(model)) {
+                return {
+                    originalTokenCount,
+                    newTokenCount: originalTokenCount,
+                    compressionStatus: CompressionStatus.NOOP,
+                };
+            }
+        }
+        let compressBeforeIndex = findIndexAfterFraction(curatedHistory, 1 - COMPRESSION_PRESERVE_THRESHOLD);
+        // Find the first user message after the index. This is the start of the next turn.
+        while (compressBeforeIndex < curatedHistory.length &&
+            (((_a = curatedHistory[compressBeforeIndex]) === null || _a === void 0 ? void 0 : _a.role) === 'assistant' ||
+                isFunctionResponse(curatedHistory[compressBeforeIndex]))) {
+            compressBeforeIndex++;
+        }
+        const historyToCompress = curatedHistory.slice(0, compressBeforeIndex);
+        const historyToKeep = curatedHistory.slice(compressBeforeIndex);
+        // Generate AI summary using the compression prompt
+        const summary = await this.generateCompressionSummary(historyToCompress);
+        const compressedMessages = [
+            {
+                role: 'user',
+                content: summary
+            },
+            {
+                role: 'assistant',
+                content: 'Got it. Thanks for the additional context!'
+            },
+            ...historyToKeep,
+        ];
+        const newTokenCount = await this.countTokens(model, compressedMessages);
+        if (newTokenCount === undefined) {
+            console.warn('Could not determine compressed history token count.');
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount,
+                newTokenCount: originalTokenCount,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR,
+            };
+        }
+        if (newTokenCount > originalTokenCount) {
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount,
+                newTokenCount,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+            };
+        }
+        return {
+            originalTokenCount,
+            newTokenCount,
+            compressionStatus: CompressionStatus.COMPRESSED,
+            compressedMessages,
+        };
+    }
+    async countTokens(model, messages) {
+        // Mock token counting - should be replaced with actual API call
+        // 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);
+        return Math.ceil(totalCharacters / 4);
+    }
+    async generateCompressionSummary(messages) {
+        // This should use the actual compression prompt and LLM call
+        // For now, using a simplified version similar to the original
+        const compressionPrompt = `You are tasked with creating a concise summary of a conversation history to preserve context while reducing token usage.
+
+Please analyze the conversation and create a state snapshot that captures:
+1. Key topics discussed
+2. Important decisions made
+3. Current context and progress
+4. Any ongoing tasks or issues
+
+Format your response as a clear, structured summary that maintains the essential information needed to continue the conversation effectively.`;
+        // Mock LLM call - should be replaced with actual LLM integration
+        const summaryParts = [];
+        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') {
+                if (content.length > 20) {
+                    userQuestions.push(content.substring(0, 150) + (content.length > 150 ? '...' : ''));
+                }
+            }
+            else if (message.role === 'assistant') {
+                if (content.length > 20) {
+                    assistantResponses.push(content.substring(0, 150) + (content.length > 150 ? '...' : ''));
+                }
+            }
+        }
+        summaryParts.push('<state_snapshot>');
+        summaryParts.push('This is a compressed summary of the previous conversation:');
+        summaryParts.push('');
+        if (userQuestions.length > 0) {
+            summaryParts.push('Key user requests and questions:');
+            userQuestions.slice(0, 5).forEach((q, i) => {
+                summaryParts.push(`${i + 1}. ${q}`);
+            });
+            summaryParts.push('');
+        }
+        if (assistantResponses.length > 0) {
+            summaryParts.push('Key assistant responses and actions:');
+            assistantResponses.slice(0, 5).forEach((r, i) => {
+                summaryParts.push(`${i + 1}. ${r}`);
+            });
+            summaryParts.push('');
+        }
+        summaryParts.push(`Total messages compressed: ${messages.length}`);
+        summaryParts.push('</state_snapshot>');
+        return summaryParts.join('\n');
+    }
+    resetCompressionState() {
+        this.hasFailedCompressionAttempt = false;
+    }
+}
+exports.ChatCompressionModifier = ChatCompressionModifier;
+////

package/dist/processor-pieces/preInferenceProcessors/conversationCompaction.d.ts

@@ -0,0 +1,7 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePreInferenceProcessor } from "../base";
+import { FlatUserMessage } from "@codebolt/types/sdk";
+export declare class ConversationCompection extends BasePreInferenceProcessor {
+    constructor();
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+}

package/dist/processor-pieces/preInferenceProcessors/conversationCompaction.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompection = void 0;
+const base_1 = require("../base");
+class ConversationCompection extends base_1.BasePreInferenceProcessor {
+    constructor() {
+        super();
+    }
+    modify(originalRequest, createdMessage) {
+        const updatedMessages = createdMessage.message.messages.map(message => {
+            if (message.role === 'user') {
+                return {
+                    ...message,
+                    content: `${message.content} user message compected`
+                };
+            }
+            return message;
+        });
+        return Promise.resolve({
+            message: {
+                ...createdMessage.message,
+                messages: updatedMessages
+            },
+            metadata: {
+                ...createdMessage.metadata,
+                chatsummerized: true
+            }
+        });
+    }
+}
+exports.ConversationCompection = ConversationCompection;

package/dist/processor-pieces/preInferenceProcessors/index.d.ts

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

package/dist/processor-pieces/preInferenceProcessors/index.js

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

package/dist/processor-pieces/preToolCall/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pre-Tool Call Processors
+ *
+ * These processors run before tool execution and can intercept, validate,
+ * or modify tool calls before they are sent to the actual tool execution engine.
+ */
+export { LocalToolInterceptorProcessor, type LocalToolInterceptorInfo, type LocalToolInterceptorProcessorOptions, type LocalToolHandler } from './localToolInterceptorProcessor';
+export { ToolValidationProcessor, type ToolValidationInfo, type ToolValidationProcessorOptions } from './toolValidationProcessor';
+export { ToolParameterModifierProcessor, type ToolParameterModificationInfo, type ParameterTransformation, type ToolParameterModifierProcessorOptions } from './toolParameterModifierProcessor';

package/dist/processor-pieces/preToolCall/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Pre-Tool Call Processors
+ *
+ * These processors run before tool execution and can intercept, validate,
+ * or modify tool calls before they are sent to the actual tool execution engine.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolParameterModifierProcessor = exports.ToolValidationProcessor = exports.LocalToolInterceptorProcessor = void 0;
+// Local tool interceptor
+var localToolInterceptorProcessor_1 = require("./localToolInterceptorProcessor");
+Object.defineProperty(exports, "LocalToolInterceptorProcessor", { enumerable: true, get: function () { return localToolInterceptorProcessor_1.LocalToolInterceptorProcessor; } });
+// Tool validation processor
+var toolValidationProcessor_1 = require("./toolValidationProcessor");
+Object.defineProperty(exports, "ToolValidationProcessor", { enumerable: true, get: function () { return toolValidationProcessor_1.ToolValidationProcessor; } });
+// Tool parameter modifier processor
+var toolParameterModifierProcessor_1 = require("./toolParameterModifierProcessor");
+Object.defineProperty(exports, "ToolParameterModifierProcessor", { enumerable: true, get: function () { return toolParameterModifierProcessor_1.ToolParameterModifierProcessor; } });

package/dist/processor-pieces/preToolCall/localToolInterceptorProcessor.d.ts

@@ -0,0 +1,58 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface LocalToolInterceptorInfo {
+    toolName: string;
+    intercepted: boolean;
+    executionMethod: 'local' | 'custom' | 'delegated';
+    executionTime: number;
+    result: string;
+}
+export interface LocalToolInterceptorProcessorOptions {
+    localTools?: Map<string, LocalToolHandler>;
+    enableCustomToolHandling?: boolean;
+    enableToolDelegation?: boolean;
+    defaultExecutionTimeout?: number;
+    enableLogging?: boolean;
+}
+export interface LocalToolHandler {
+    name: string;
+    description?: string;
+    execute: (params: any, context?: Record<string, any>) => Promise<string> | string;
+    validate?: (params: any) => boolean;
+    timeout?: number;
+}
+/**
+ * Processor that intercepts specific tool calls and handles them locally
+ * instead of sending them to external tool execution services.
+ */
+export declare class LocalToolInterceptorProcessor extends BaseProcessor {
+    private readonly localTools;
+    private readonly enableCustomToolHandling;
+    private readonly enableToolDelegation;
+    private readonly defaultExecutionTimeout;
+    private readonly enableLogging;
+    constructor(options?: LocalToolInterceptorProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private shouldInterceptTool;
+    private executeLocalTool;
+    private executeToolHandler;
+    private handleLocalPrefixTool;
+    private handleCustomPrefixTool;
+    private handleInternalPrefixTool;
+    private handleLocalFileRead;
+    private handleLocalFileWrite;
+    private handleLocalScriptExecution;
+    private handleDataValidation;
+    private handleDataTransformation;
+    private handleCalculation;
+    private handleOutputFormatting;
+    private getExecutionMethod;
+    private generateUUID;
+    private simpleHash;
+    private toYamlLike;
+    private toCsv;
+    private toTable;
+    addLocalTool(handler: LocalToolHandler): void;
+    removeLocalTool(toolName: string): boolean;
+    getLocalTools(): string[];
+    hasLocalTool(toolName: string): boolean;
+}