@codebolt/agent 5.0.1 → 5.0.6

package/dist/processor-pieces/preInference/conversationContinuityProcessor.js

@@ -1,293 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConversationContinuityProcessor = void 0;
-const processorTypes_1 = require("../types/processorTypes");
-/**
- * Processor that maintains conversation continuity by linking related messages,
- * resolving references, and detecting context gaps in follow-up conversations.
- */
-class ConversationContinuityProcessor extends processorTypes_1.BaseProcessor {
-    constructor(options = {}) {
-        super(options);
-        this.enableContextLinking = options.enableContextLinking !== false;
-        this.enableReferenceResolution = options.enableReferenceResolution !== false;
-        this.enableGapDetection = options.enableGapDetection !== false;
-        this.maxContextLinks = options.maxContextLinks || 5;
-        this.contextLookbackWindow = options.contextLookbackWindow || 20;
-        this.enableProactiveContext = options.enableProactiveContext !== false;
-    }
-    async processInput(input) {
-        try {
-            const { message, context } = input;
-            // Only process follow-up conversations
-            if (!(context === null || context === void 0 ? void 0 : context.followUpProcessing)) {
-                return [this.createEvent('ContinuityProcessingSkipped', {
-                        reason: 'Not a follow-up conversation processing context'
-                    })];
-            }
-            const enhancedMessage = await this.enhanceConversationContinuity(message, context);
-            const continuityInfo = this.calculateContinuityInfo(message, enhancedMessage, context);
-            return [
-                this.createEvent('ConversationContinuityProcessed', continuityInfo),
-                this.createEvent('ConversationProcessed', enhancedMessage)
-            ];
-        }
-        catch (error) {
-            console.error('Error in ConversationContinuityProcessor:', error);
-            return [this.createEvent('ConversationContinuityError', {
-                    error: error instanceof Error ? error.message : String(error),
-                    originalLength: input.message.messages.length
-                })];
-        }
-    }
-    async enhanceConversationContinuity(message, context) {
-        let enhancedMessages = [...message.messages];
-        let enhancementsAdded = 0;
-        // Add context links if enabled
-        if (this.enableContextLinking) {
-            const contextLinks = this.addContextLinks(enhancedMessages, context);
-            enhancedMessages.push(...contextLinks);
-            enhancementsAdded += contextLinks.length;
-        }
-        // Resolve references if enabled
-        if (this.enableReferenceResolution) {
-            enhancedMessages = this.resolveReferences(enhancedMessages, context);
-        }
-        // Detect and fill conversation gaps if enabled
-        if (this.enableGapDetection) {
-            const gapFillers = this.detectAndFillGaps(enhancedMessages, context);
-            enhancedMessages.push(...gapFillers);
-            enhancementsAdded += gapFillers.length;
-        }
-        // Add proactive context if enabled
-        if (this.enableProactiveContext) {
-            const proactiveContext = this.addProactiveContext(enhancedMessages, context);
-            enhancedMessages.push(...proactiveContext);
-            enhancementsAdded += proactiveContext.length;
-        }
-        return {
-            ...message,
-            messages: enhancedMessages,
-            metadata: {
-                ...message.metadata,
-                continuityEnhanced: true,
-                enhancementsAdded,
-                timestamp: new Date().toISOString()
-            }
-        };
-    }
-    addContextLinks(messages, context) {
-        const contextLinks = [];
-        const recentMessages = messages.slice(-this.contextLookbackWindow);
-        // Find messages that reference previous interactions
-        const referencingMessages = this.findReferencingMessages(recentMessages);
-        if (referencingMessages.length > 0) {
-            const linkMessage = {
-                role: 'system',
-                content: this.generateContextLinkMessage(referencingMessages, context),
-                name: 'context-link'
-            };
-            contextLinks.push(linkMessage);
-        }
-        return contextLinks.slice(0, this.maxContextLinks);
-    }
-    findReferencingMessages(messages) {
-        const referencePatterns = [
-            /\b(this|that|it|they|them)\b/i,
-            /\b(the (above|previous|last|earlier))\b/i,
-            /\b(as (mentioned|discussed|shown))\b/i,
-            /\b(from (before|earlier))\b/i,
-            /\b(the (file|code|result|output))\b/i
-        ];
-        return messages.filter(message => {
-            const content = typeof message.content === 'string'
-                ? message.content
-                : JSON.stringify(message.content);
-            return referencePatterns.some(pattern => pattern.test(content));
-        });
-    }
-    generateContextLinkMessage(referencingMessages, context) {
-        const messageCount = referencingMessages.length;
-        const toolResults = context.toolResults || [];
-        let linkMessage = `**Context Links:** Found ${messageCount} message${messageCount > 1 ? 's' : ''} with references to previous interactions.`;
-        if (toolResults.length > 0) {
-            linkMessage += ` Recent tool executions: ${toolResults.length} tool${toolResults.length > 1 ? 's' : ''} executed.`;
-        }
-        if (context.originalHistory && context.originalHistory.length > 0) {
-            linkMessage += ` Conversation history: ${context.originalHistory.length} previous messages available for reference.`;
-        }
-        return linkMessage;
-    }
-    resolveReferences(messages, context) {
-        return messages.map(message => {
-            if (message.role === 'system' || message.name === 'reference-resolution') {
-                return message;
-            }
-            const resolvedContent = this.resolveMessageReferences(message.content, context);
-            if (resolvedContent !== message.content) {
-                return {
-                    ...message,
-                    content: resolvedContent,
-                    name: message.name || 'reference-resolved'
-                };
-            }
-            return message;
-        });
-    }
-    resolveMessageReferences(content, context) {
-        if (typeof content !== 'string') {
-            return content;
-        }
-        let resolvedContent = content;
-        const toolResults = context.toolResults || [];
-        // Resolve "the file" references
-        if (/\bthe file\b/i.test(resolvedContent) && toolResults.length > 0) {
-            const fileOperations = toolResults.filter((result) => result.tool_call_id && result.tool_call_id.includes('file'));
-            if (fileOperations.length === 1) {
-                resolvedContent = resolvedContent.replace(/\bthe file\b/gi, `the file (from recent tool execution)`);
-            }
-        }
-        // Resolve "the result" references
-        if (/\bthe result\b/i.test(resolvedContent) && toolResults.length > 0) {
-            resolvedContent = resolvedContent.replace(/\bthe result\b/gi, `the result (from ${toolResults.length} recent tool execution${toolResults.length > 1 ? 's' : ''})`);
-        }
-        // Resolve "it" references in context of tool operations
-        if (/\bit\b/i.test(resolvedContent) && toolResults.length === 1) {
-            const toolResult = toolResults[0];
-            if (toolResult.tool_call_id) {
-                resolvedContent = resolvedContent.replace(/\bit\b/gi, `it (referring to the tool execution result)`);
-            }
-        }
-        return resolvedContent;
-    }
-    detectAndFillGaps(messages, context) {
-        const gapFillers = [];
-        const gaps = this.detectConversationGaps(messages, context);
-        gaps.forEach(gap => {
-            const fillerMessage = {
-                role: 'system',
-                content: this.generateGapFillerMessage(gap, context),
-                name: 'gap-filler'
-            };
-            gapFillers.push(fillerMessage);
-        });
-        return gapFillers;
-    }
-    detectConversationGaps(messages, context) {
-        const gaps = [];
-        const toolResults = context.toolResults || [];
-        // Gap: Tool results without explanation
-        const unexplainedToolResults = toolResults.filter((result) => {
-            const hasExplanation = messages.some(msg => msg.role === 'assistant' &&
-                typeof msg.content === 'string' &&
-                msg.content.includes('result'));
-            return !hasExplanation;
-        });
-        if (unexplainedToolResults.length > 0) {
-            gaps.push({
-                type: 'unexplained-tool-results',
-                description: `${unexplainedToolResults.length} tool result(s) without explanation`,
-                severity: 'medium'
-            });
-        }
-        // Gap: Missing context for references
-        const unresolvedReferences = messages.filter(msg => {
-            const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
-            return /\b(this|that|it)\b/i.test(content) && msg.role === 'user';
-        });
-        if (unresolvedReferences.length > 2) {
-            gaps.push({
-                type: 'unresolved-references',
-                description: `${unresolvedReferences.length} messages with unclear references`,
-                severity: 'low'
-            });
-        }
-        // Gap: Long silence after tool execution
-        const lastToolIndex = messages.findLastIndex(msg => msg.role === 'tool');
-        const lastAssistantIndex = messages.findLastIndex(msg => msg.role === 'assistant');
-        if (lastToolIndex > lastAssistantIndex && lastToolIndex < messages.length - 1) {
-            gaps.push({
-                type: 'missing-tool-response',
-                description: 'Tool execution without assistant response',
-                severity: 'high'
-            });
-        }
-        return gaps;
-    }
-    generateGapFillerMessage(gap, context) {
-        switch (gap.type) {
-            case 'unexplained-tool-results':
-                return `**Context Note:** There are tool execution results that may need explanation or analysis. Consider reviewing the tool outputs and their implications.`;
-            case 'unresolved-references':
-                return `**Context Note:** Some messages contain references that might be unclear. Consider providing more specific context when referring to previous interactions.`;
-            case 'missing-tool-response':
-                return `**Context Note:** Recent tool execution completed but may need assistant analysis or response to continue the conversation effectively.`;
-            default:
-                return `**Context Note:** Potential conversation gap detected: ${gap.description}`;
-        }
-    }
-    addProactiveContext(messages, context) {
-        const proactiveMessages = [];
-        const toolResults = context.toolResults || [];
-        const conversationLength = messages.length;
-        // Add proactive context for complex tool interactions
-        if (toolResults.length > 3) {
-            proactiveMessages.push({
-                role: 'system',
-                content: `**Proactive Context:** Multiple tools have been executed (${toolResults.length} total). This suggests a complex task that may benefit from step-by-step progress tracking.`,
-                name: 'proactive-context'
-            });
-        }
-        // Add proactive context for long conversations
-        if (conversationLength > 25) {
-            proactiveMessages.push({
-                role: 'system',
-                content: `**Proactive Context:** This is an extended conversation (${conversationLength} messages). Consider summarizing progress or breaking down remaining objectives.`,
-                name: 'proactive-context'
-            });
-        }
-        return proactiveMessages.slice(0, 2); // Limit proactive messages
-    }
-    calculateContinuityInfo(original, enhanced, context) {
-        const originalCount = original.messages.length;
-        const enhancedCount = enhanced.messages.length;
-        const addedMessages = enhancedCount - originalCount;
-        // Count different types of enhancements
-        const contextLinks = enhanced.messages.filter(m => m.name === 'context-link').length;
-        const referenceResolutions = enhanced.messages.filter(m => m.name === 'reference-resolved').length;
-        const gapFillers = enhanced.messages.filter(m => m.name === 'gap-filler').length;
-        return {
-            contextLinksAdded: contextLinks,
-            referenceResolutionsAdded: referenceResolutions,
-            continuityEnhanced: addedMessages > 0,
-            missingContextDetected: gapFillers > 0,
-            conversationGapsFound: gapFillers
-        };
-    }
-    // Public methods for configuration
-    setContextLookbackWindow(window) {
-        this.contextLookbackWindow = Math.max(5, Math.min(50, window));
-    }
-    setMaxContextLinks(max) {
-        this.maxContextLinks = Math.max(1, Math.min(10, max));
-    }
-    enableContextLinkingForSession() {
-        this.enableContextLinking = true;
-    }
-    disableContextLinkingForSession() {
-        this.enableContextLinking = false;
-    }
-    enableReferenceResolutionForSession() {
-        this.enableReferenceResolution = true;
-    }
-    disableReferenceResolutionForSession() {
-        this.enableReferenceResolution = false;
-    }
-    enableGapDetectionForSession() {
-        this.enableGapDetection = true;
-    }
-    disableGapDetectionForSession() {
-        this.enableGapDetection = false;
-    }
-}
-exports.ConversationContinuityProcessor = ConversationContinuityProcessor;

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

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

@@ -1,31 +0,0 @@
-"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/preToolCall/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-"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

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