@codebolt/agent 2.2.2 → 2.2.3

package/dist/processor-pieces/postToolCall/followUpConversationProcessor.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowUpConversationProcessor = void 0;
+const processor_1 = require("../../processor");
+/**
+ * Processor that enhances follow-up conversations by adding contextual information,
+ * improving tool result presentation, and providing guidance for continued interaction.
+ */
+class FollowUpConversationProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.addFollowUpPrompts = options.addFollowUpPrompts !== false;
+        this.enhanceToolResults = options.enhanceToolResults !== false;
+        this.addContextualHints = options.addContextualHints !== false;
+        this.processingMode = options.processingMode || 'automatic';
+        this.maxFollowUpMessages = options.maxFollowUpMessages || 3;
+        this.enableToolResultEnhancement = options.enableToolResultEnhancement !== false;
+        this.enableConversationGuidance = options.enableConversationGuidance !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            // Check if this is a follow-up conversation processing
+            if (!(context === null || context === void 0 ? void 0 : context.followUpProcessing)) {
+                return [this.createEvent('FollowUpProcessingSkipped', {
+                        reason: 'Not a follow-up conversation processing context'
+                    })];
+            }
+            const enhancedMessage = await this.enhanceFollowUpConversation(message, context);
+            const processingInfo = this.calculateProcessingInfo(message, enhancedMessage, context);
+            return [
+                this.createEvent('FollowUpConversationProcessed', processingInfo),
+                this.createEvent('ConversationProcessed', enhancedMessage)
+            ];
+        }
+        catch (error) {
+            console.error('Error in FollowUpConversationProcessor:', error);
+            return [this.createEvent('FollowUpConversationError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    originalLength: input.message.messages.length
+                })];
+        }
+    }
+    async enhanceFollowUpConversation(message, context) {
+        let enhancedMessages = [...message.messages];
+        let enhancementsAdded = 0;
+        // Enhance tool results if enabled
+        if (this.enableToolResultEnhancement && this.enhanceToolResults) {
+            enhancedMessages = this.enhanceToolResultMessages(enhancedMessages, context);
+            enhancementsAdded++;
+        }
+        // Add follow-up prompts if enabled
+        if (this.addFollowUpPrompts && this.processingMode !== 'minimal') {
+            const followUpMessages = this.generateFollowUpPrompts(enhancedMessages, context);
+            enhancedMessages.push(...followUpMessages);
+            enhancementsAdded += followUpMessages.length;
+        }
+        // Add contextual hints if enabled
+        if (this.addContextualHints && this.enableConversationGuidance) {
+            const contextualMessages = this.generateContextualHints(enhancedMessages, context);
+            enhancedMessages.push(...contextualMessages);
+            enhancementsAdded += contextualMessages.length;
+        }
+        return {
+            ...message,
+            messages: enhancedMessages,
+            metadata: {
+                ...message.metadata,
+                followUpEnhanced: true,
+                enhancementsAdded,
+                processingMode: this.processingMode,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+    enhanceToolResultMessages(messages, context) {
+        return messages.map(message => {
+            if (message.role !== 'tool') {
+                return message;
+            }
+            // Enhance tool result presentation
+            const enhancedContent = this.enhanceToolResultContent(message.content, context);
+            return {
+                ...message,
+                content: enhancedContent,
+                name: message.name || 'tool-result'
+            };
+        });
+    }
+    enhanceToolResultContent(content, context) {
+        if (typeof content !== 'string') {
+            return content;
+        }
+        // Add formatting and context to tool results
+        let enhancedContent = content;
+        // Add success/failure indicators
+        if (content.toLowerCase().includes('error') || content.toLowerCase().includes('failed')) {
+            enhancedContent = `❌ **Tool Execution Result:**\n${content}\n\n*The tool encountered an issue. Please review the error and try again if needed.*`;
+        }
+        else if (content.toLowerCase().includes('success') || content.toLowerCase().includes('completed')) {
+            enhancedContent = `✅ **Tool Execution Result:**\n${content}\n\n*The tool executed successfully.*`;
+        }
+        else {
+            enhancedContent = `🔧 **Tool Execution Result:**\n${content}`;
+        }
+        // Add tool execution context if available
+        if (context.toolResults && Array.isArray(context.toolResults)) {
+            const toolCount = context.toolResults.length;
+            if (toolCount > 1) {
+                enhancedContent += `\n\n*This is one of ${toolCount} tool results in this interaction.*`;
+            }
+        }
+        return enhancedContent;
+    }
+    generateFollowUpPrompts(messages, context) {
+        const followUpMessages = [];
+        const toolResults = context.toolResults || [];
+        const hasErrors = toolResults.some((result) => result.content && result.content.toLowerCase().includes('error'));
+        // Add different prompts based on processing mode
+        switch (this.processingMode) {
+            case 'guided':
+                followUpMessages.push(...this.generateGuidedPrompts(messages, context, hasErrors));
+                break;
+            case 'automatic':
+                followUpMessages.push(...this.generateAutomaticPrompts(messages, context, hasErrors));
+                break;
+            case 'minimal':
+                // Minimal mode doesn't add prompts
+                break;
+        }
+        // Limit the number of follow-up messages
+        return followUpMessages.slice(0, this.maxFollowUpMessages);
+    }
+    generateGuidedPrompts(messages, context, hasErrors) {
+        var _a;
+        const prompts = [];
+        if (hasErrors) {
+            prompts.push({
+                role: 'user',
+                content: "I notice there were some errors in the tool execution. Would you like me to:\n1. Retry the failed operations\n2. Try an alternative approach\n3. Provide more details about the errors\n4. Continue with the successful results\n\nPlease let me know how you'd like to proceed.",
+                name: 'error-guidance-prompt'
+            });
+        }
+        else {
+            const toolCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            if (toolCount > 0) {
+                prompts.push({
+                    role: 'user',
+                    content: `The tools have been executed successfully. Based on the results, would you like me to:\n1. Analyze the results further\n2. Perform additional related tasks\n3. Provide a summary of what was accomplished\n4. Continue with the next steps\n\nWhat would be most helpful?`,
+                    name: 'success-guidance-prompt'
+                });
+            }
+        }
+        return prompts;
+    }
+    generateAutomaticPrompts(messages, context, hasErrors) {
+        var _a;
+        const prompts = [];
+        if (hasErrors) {
+            prompts.push({
+                role: 'user',
+                content: "Please review the errors above and suggest how to resolve them or continue with alternative approaches.",
+                name: 'automatic-error-prompt'
+            });
+        }
+        else {
+            const toolCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
+            if (toolCount > 0) {
+                prompts.push({
+                    role: 'user',
+                    content: "Please analyze the tool execution results and let me know if there are any next steps or if the task has been completed successfully.",
+                    name: 'automatic-success-prompt'
+                });
+            }
+        }
+        return prompts;
+    }
+    generateContextualHints(messages, context) {
+        const hints = [];
+        const toolResults = context.toolResults || [];
+        const conversationLength = context.conversationLength || 0;
+        // Add hints based on conversation state
+        if (conversationLength > 30) {
+            hints.push({
+                role: 'system',
+                content: "Note: This conversation is getting quite long. Consider summarizing progress or breaking down remaining tasks into smaller steps.",
+                name: 'conversation-length-hint'
+            });
+        }
+        // Add hints based on tool execution patterns
+        if (toolResults.length > 5) {
+            hints.push({
+                role: 'system',
+                content: "Multiple tools have been executed in this interaction. Consider reviewing the overall progress and determining if the objectives have been met.",
+                name: 'tool-execution-hint'
+            });
+        }
+        // Add hints for specific tool types
+        const fileOperations = toolResults.filter((result) => result.tool_call_id && (result.tool_call_id.includes('file') ||
+            result.tool_call_id.includes('read') ||
+            result.tool_call_id.includes('write')));
+        if (fileOperations.length > 0) {
+            hints.push({
+                role: 'system',
+                content: "File operations have been performed. Consider verifying the changes and ensuring all modifications are correct.",
+                name: 'file-operations-hint'
+            });
+        }
+        return hints.slice(0, 2); // Limit hints to avoid clutter
+    }
+    calculateProcessingInfo(original, enhanced, context) {
+        var _a;
+        const originalCount = original.messages.length;
+        const enhancedCount = enhanced.messages.length;
+        const toolResultsCount = ((_a = context.toolResults) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        return {
+            toolResultsProcessed: toolResultsCount,
+            followUpMessagesAdded: enhancedCount - originalCount,
+            conversationEnhanced: enhancedCount > originalCount,
+            processingMethod: this.processingMode
+        };
+    }
+    // Public methods for configuration
+    setProcessingMode(mode) {
+        this.processingMode = mode;
+    }
+    setMaxFollowUpMessages(count) {
+        this.maxFollowUpMessages = Math.max(0, Math.min(10, count));
+    }
+    enableFollowUpPromptsForSession() {
+        this.addFollowUpPrompts = true;
+    }
+    disableFollowUpPromptsForSession() {
+        this.addFollowUpPrompts = false;
+    }
+    enableToolResultEnhancementForSession() {
+        this.enableToolResultEnhancement = true;
+    }
+    disableToolResultEnhancementForSession() {
+        this.enableToolResultEnhancement = false;
+    }
+    enableConversationGuidanceForSession() {
+        this.enableConversationGuidance = true;
+    }
+    disableConversationGuidanceForSession() {
+        this.enableConversationGuidance = false;
+    }
+}
+exports.FollowUpConversationProcessor = FollowUpConversationProcessor;

package/dist/processor-pieces/postToolCall/loopDetectionProcessor.d.ts

@@ -0,0 +1,30 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface LoopDetectionInfo {
+    promptId: string;
+    loopCount: number;
+    maxLoops: number;
+    recentMessages: any[];
+    isLoop: boolean;
+}
+export interface LoopDetectionProcessorOptions {
+    maxLoops?: number;
+    messageThreshold?: number;
+    enableLoopDetection?: boolean;
+}
+export declare class LoopDetectionProcessor extends BaseProcessor {
+    private readonly maxLoops;
+    private readonly messageThreshold;
+    private readonly enableLoopDetection;
+    private lastPromptId;
+    private loopCount;
+    constructor(options?: LoopDetectionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private generatePromptId;
+    private resetLoopDetector;
+    private checkLoopDetection;
+    resetSession(): void;
+    getCurrentLoopCount(): number;
+    setMaxLoops(maxLoops: number): void;
+    enableLoopDetectionForSession(): void;
+    disableLoopDetectionForSession(): void;
+}

package/dist/processor-pieces/postToolCall/loopDetectionProcessor.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopDetectionProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class LoopDetectionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.lastPromptId = null;
+        this.loopCount = 0;
+        this.maxLoops = options.maxLoops || 3;
+        this.messageThreshold = options.messageThreshold || 6;
+        this.enableLoopDetection = options.enableLoopDetection !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            if (!this.enableLoopDetection) {
+                return [this.createEvent('LoopDetectionDisabled', {
+                        reason: 'Loop detection is disabled for this session'
+                    })];
+            }
+            // Get prompt ID from context or generate one
+            const promptId = (context === null || context === void 0 ? void 0 : context.promptId) || this.generatePromptId();
+            // Reset loop detector if new prompt
+            if (this.lastPromptId !== promptId) {
+                await this.resetLoopDetector(promptId);
+                this.lastPromptId = promptId;
+            }
+            else {
+                this.loopCount++;
+            }
+            // Check for conversation loops using CodeBolt state
+            const loopDetected = await this.checkLoopDetection();
+            if (loopDetected) {
+                // Send notification about loop detection
+                await codeboltjs_1.default.chat.sendNotificationEvent('Loop detected in conversation', 'debug');
+                return [this.createEvent('LoopDetected', {
+                        promptId,
+                        loopCount: this.loopCount,
+                        maxLoops: this.maxLoops
+                    })];
+            }
+            // Check if max loops reached
+            if (this.loopCount > this.maxLoops) {
+                return [this.createEvent('MaxLoopsReached', {
+                        promptId,
+                        loopCount: this.loopCount,
+                        maxLoops: this.maxLoops
+                    })];
+            }
+            // Continue processing
+            return [this.createEvent('LoopDetectionPassed', {
+                    promptId,
+                    loopCount: this.loopCount,
+                    maxLoops: this.maxLoops
+                })];
+        }
+        catch (error) {
+            console.error('Error in LoopDetectionProcessor:', error);
+            return [this.createEvent('LoopDetectionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    generatePromptId() {
+        return `prompt-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async resetLoopDetector(promptId) {
+        this.loopCount = 0;
+        this.setContext('currentPromptId', promptId);
+        this.setContext('loopDetectorReset', Date.now().toString());
+        // Update CodeBolt agent state
+        try {
+            await codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', promptId);
+            await codeboltjs_1.default.cbstate.addToAgentState('loopDetectorReset', Date.now().toString());
+        }
+        catch (error) {
+            console.warn('Failed to update CodeBolt agent state:', error);
+        }
+    }
+    async checkLoopDetection() {
+        var _a;
+        try {
+            // Get recent messages from CodeBolt state
+            const agentState = await codeboltjs_1.default.cbstate.getAgentState();
+            const recentMessages = ((_a = agentState.data) === null || _a === void 0 ? void 0 : _a.recentMessages) || [];
+            // Simple loop detection: check for repeated patterns
+            if (recentMessages.length >= this.messageThreshold) {
+                const lastThree = recentMessages.slice(-3);
+                const previousThree = recentMessages.slice(-6, -3);
+                if (lastThree.length === 3 && previousThree.length === 3) {
+                    const isLoop = JSON.stringify(lastThree) === JSON.stringify(previousThree);
+                    if (isLoop) {
+                        console.log('[Loop Detection] Loop detected in conversation');
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            console.warn('Failed to check loop detection:', error);
+            return false;
+        }
+    }
+    // Public methods for external control
+    resetSession() {
+        this.loopCount = 0;
+        this.lastPromptId = null;
+        this.clearContext();
+        // Clear CodeBolt agent state
+        try {
+            codeboltjs_1.default.cbstate.addToAgentState('sessionTurnCount', '0');
+            codeboltjs_1.default.cbstate.addToAgentState('lastPromptId', '');
+        }
+        catch (error) {
+            console.warn('Failed to clear CodeBolt agent state:', error);
+        }
+    }
+    getCurrentLoopCount() {
+        return this.loopCount;
+    }
+    setMaxLoops(maxLoops) {
+        this.maxLoops = Math.max(1, maxLoops);
+    }
+    enableLoopDetectionForSession() {
+        this.enableLoopDetection = true;
+    }
+    disableLoopDetectionForSession() {
+        this.enableLoopDetection = false;
+    }
+}
+exports.LoopDetectionProcessor = LoopDetectionProcessor;

package/dist/processor-pieces/postToolCall/responseValidationProcessor.d.ts

@@ -0,0 +1,30 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ResponseValidationProcessorOptions {
+    validateToolCalls?: boolean;
+    validateContent?: boolean;
+    validateStructure?: boolean;
+    allowEmptyContent?: boolean;
+    maxContentLength?: number;
+    requiredFields?: string[];
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    fixes: string[];
+}
+export declare class ResponseValidationProcessor extends BaseProcessor {
+    private readonly enableToolCallValidation;
+    private readonly validateContent;
+    private readonly validateStructure;
+    private readonly allowEmptyContent;
+    private readonly maxContentLength;
+    private readonly requiredFields;
+    constructor(options?: ResponseValidationProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private validateMessage;
+    private validateMessageStructure;
+    private validateMessageContent;
+    private validateToolCallsInMessage;
+    getValidationSummary(validationResult: ValidationResult): string;
+}

package/dist/processor-pieces/postToolCall/responseValidationProcessor.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseValidationProcessor = void 0;
+const processor_1 = require("../../processor");
+class ResponseValidationProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super();
+        this.enableToolCallValidation = options.validateToolCalls !== false;
+        this.validateContent = options.validateContent !== false;
+        this.validateStructure = options.validateStructure !== false;
+        this.allowEmptyContent = options.allowEmptyContent || false;
+        this.maxContentLength = options.maxContentLength || 100000;
+        this.requiredFields = options.requiredFields || ['role'];
+    }
+    async processInput(input) {
+        var _a;
+        const { message } = input;
+        const validationResult = this.validateMessage(message);
+        const results = [
+            this.createEvent('ValidationCompleted', {
+                result: validationResult,
+                messageId: ((_a = message.metadata) === null || _a === void 0 ? void 0 : _a.id) || 'unknown'
+            })
+        ];
+        if (!validationResult.isValid) {
+            results.push(this.createEvent('ValidationFailed', {
+                errors: validationResult.errors,
+                warnings: validationResult.warnings,
+                fixes: validationResult.fixes
+            }));
+        }
+        if (validationResult.warnings.length > 0) {
+            results.push(this.createEvent('ValidationWarnings', {
+                warnings: validationResult.warnings
+            }));
+        }
+        return results;
+    }
+    validateMessage(message) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Structure validation
+        if (this.validateStructure) {
+            const structureValidation = this.validateMessageStructure(message);
+            errors.push(...structureValidation.errors);
+            warnings.push(...structureValidation.warnings);
+            fixes.push(...structureValidation.fixes);
+        }
+        // Content validation
+        if (this.validateContent && message.messages) {
+            for (let i = 0; i < message.messages.length; i++) {
+                const msg = message.messages[i];
+                const contentValidation = this.validateMessageContent(msg, i);
+                errors.push(...contentValidation.errors);
+                warnings.push(...contentValidation.warnings);
+                fixes.push(...contentValidation.fixes);
+            }
+        }
+        // Tool calls validation
+        if (this.enableToolCallValidation && message.messages) {
+            for (let i = 0; i < message.messages.length; i++) {
+                const msg = message.messages[i];
+                if (msg.tool_calls) {
+                    const toolValidation = this.validateToolCallsInMessage(msg.tool_calls, i);
+                    errors.push(...toolValidation.errors);
+                    warnings.push(...toolValidation.warnings);
+                    fixes.push(...toolValidation.fixes);
+                }
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+            fixes
+        };
+    }
+    validateMessageStructure(message) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Check if message exists
+        if (!message) {
+            errors.push('Message is null or undefined');
+            fixes.push('Provide a valid message object');
+            return { isValid: false, errors, warnings, fixes };
+        }
+        // Check if messages array exists
+        if (!message.messages) {
+            errors.push('Message object missing required "messages" array');
+            fixes.push('Add a "messages" array to the message object');
+        }
+        else if (!Array.isArray(message.messages)) {
+            errors.push('Messages field must be an array');
+            fixes.push('Convert messages field to an array');
+        }
+        else if (message.messages.length === 0) {
+            warnings.push('Messages array is empty');
+        }
+        // Check metadata structure
+        if (message.metadata && typeof message.metadata !== 'object') {
+            warnings.push('Metadata should be an object');
+            fixes.push('Convert metadata to an object or remove it');
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    validateMessageContent(msg, index) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        // Check required fields
+        for (const field of this.requiredFields) {
+            if (!(field in msg)) {
+                errors.push(`Message at index ${index} missing required field: ${field}`);
+                fixes.push(`Add ${field} field to message at index ${index}`);
+            }
+        }
+        // Validate role
+        if (msg.role) {
+            const validRoles = ['user', 'assistant', 'system', 'tool'];
+            if (!validRoles.includes(msg.role)) {
+                errors.push(`Invalid role "${msg.role}" at index ${index}. Must be one of: ${validRoles.join(', ')}`);
+                fixes.push(`Change role to one of: ${validRoles.join(', ')}`);
+            }
+        }
+        // Validate content
+        if (msg.content !== undefined) {
+            if (typeof msg.content === 'string') {
+                // String content validation
+                if (!this.allowEmptyContent && msg.content.trim() === '') {
+                    warnings.push(`Empty content in message at index ${index}`);
+                    fixes.push('Provide meaningful content or remove the message');
+                }
+                if (msg.content.length > this.maxContentLength) {
+                    warnings.push(`Content too long at index ${index}: ${msg.content.length} chars (max: ${this.maxContentLength})`);
+                    fixes.push('Truncate or compress the content');
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                // Array content validation (for multimodal messages)
+                for (let partIndex = 0; partIndex < msg.content.length; partIndex++) {
+                    const part = msg.content[partIndex];
+                    if (!part || (typeof part !== 'object' && typeof part !== 'string')) {
+                        errors.push(`Invalid content part at message ${index}, part ${partIndex}`);
+                        fixes.push('Ensure all content parts are valid objects or strings');
+                    }
+                }
+            }
+            else if (typeof msg.content !== 'object') {
+                warnings.push(`Unexpected content type at index ${index}: ${typeof msg.content}`);
+            }
+        }
+        // Validate name field
+        if (msg.name && typeof msg.name !== 'string') {
+            warnings.push(`Name field should be a string at index ${index}`);
+            fixes.push('Convert name field to string');
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    validateToolCallsInMessage(toolCalls, messageIndex) {
+        const errors = [];
+        const warnings = [];
+        const fixes = [];
+        if (!Array.isArray(toolCalls)) {
+            errors.push(`Tool calls must be an array at message index ${messageIndex}`);
+            fixes.push('Convert tool_calls to an array');
+            return { isValid: false, errors, warnings, fixes };
+        }
+        for (let i = 0; i < toolCalls.length; i++) {
+            const toolCall = toolCalls[i];
+            // Check required tool call fields
+            if (!toolCall.id) {
+                errors.push(`Tool call at message ${messageIndex}, call ${i} missing required "id" field`);
+                fixes.push('Add unique id to tool call');
+            }
+            if (!toolCall.function) {
+                errors.push(`Tool call at message ${messageIndex}, call ${i} missing required "function" field`);
+                fixes.push('Add function object to tool call');
+            }
+            else {
+                // Validate function object
+                if (!toolCall.function.name) {
+                    errors.push(`Tool call function at message ${messageIndex}, call ${i} missing "name" field`);
+                    fixes.push('Add function name to tool call');
+                }
+                if (toolCall.function.arguments === undefined) {
+                    warnings.push(`Tool call function at message ${messageIndex}, call ${i} missing "arguments" field`);
+                    fixes.push('Add arguments field (can be empty object)');
+                }
+                else {
+                    // Validate arguments
+                    if (typeof toolCall.function.arguments === 'string') {
+                        try {
+                            JSON.parse(toolCall.function.arguments);
+                        }
+                        catch (e) {
+                            errors.push(`Invalid JSON in tool call arguments at message ${messageIndex}, call ${i}`);
+                            fixes.push('Ensure arguments are valid JSON string or object');
+                        }
+                    }
+                    else if (typeof toolCall.function.arguments !== 'object') {
+                        warnings.push(`Tool call arguments should be object or JSON string at message ${messageIndex}, call ${i}`);
+                    }
+                }
+            }
+        }
+        return { isValid: errors.length === 0, errors, warnings, fixes };
+    }
+    // Utility method to get validation summary
+    getValidationSummary(validationResult) {
+        const summary = [];
+        if (validationResult.isValid) {
+            summary.push('✅ Validation passed');
+        }
+        else {
+            summary.push('❌ Validation failed');
+        }
+        if (validationResult.errors.length > 0) {
+            summary.push(`${validationResult.errors.length} error(s)`);
+        }
+        if (validationResult.warnings.length > 0) {
+            summary.push(`${validationResult.warnings.length} warning(s)`);
+        }
+        return summary.join(' - ');
+    }
+}
+exports.ResponseValidationProcessor = ResponseValidationProcessor;