contaigents/dist/services/conversation/MessageBuilder.js

Modular AI Content Ecosystem with Audio Generation

import { PROVIDER_CAPABILITIES } from "../llm/types.js";
export class SystemPromptComposer {
    static compose(components) {
        return [
            components.base,
            components.fileTree ? `\n\n## Current Project Structure\n\n${components.fileTree}` : '',
            components.tools ? `\n\n${components.tools}` : '',
            components.context ? `\n\n## Additional Context\n\n${components.context}` : ''
        ].filter(Boolean).join('');
    }
}
export class ConversationMessageBuilder {
    static async buildForProvider(session, currentMessage, provider, toolManager) {
        const capabilities = PROVIDER_CAPABILITIES[provider];
        if (!capabilities) {
            throw new Error(`Unknown provider: ${provider}`);
        }
        if (capabilities.supportsConversation) {
            return this.buildConversationArray(session, currentMessage, capabilities, toolManager);
        }
        else {
            return this.buildPromptString(session, currentMessage, toolManager);
        }
    }
    static async buildConversationArray(session, currentMessage, capabilities, toolManager) {
        const messages = [];
        // Add system message if supported
        if (capabilities.supportsSystemMessages) {
            const systemContent = await this.buildSystemPrompt(session, toolManager);
            messages.push({
                id: this.generateMessageId(),
                role: 'system',
                content: systemContent,
                timestamp: Date.now()
            });
        }
        // Add conversation history (including internal tool responses for conversation flow)
        const conversationMessages = session.messages
            .filter(msg => {
            // Include all messages except system (already added above)
            return msg.role !== 'system';
        })
            .slice(-10); // Keep last 10 for context
        messages.push(...conversationMessages);
        // Add current user message
        messages.push({
            id: this.generateMessageId(),
            role: 'user',
            content: currentMessage,
            timestamp: Date.now()
        });
        return messages;
    }
    static async buildPromptString(session, currentMessage, toolManager) {
        const systemPrompt = await this.buildSystemPrompt(session, toolManager);
        // For simple prompt providers, include all conversation history including tool responses
        const conversationHistory = session.messages
            .filter(msg => msg.role !== 'system')
            .slice(-10)
            .map(msg => {
            const roleLabel = msg.role === 'assistant' ? 'assistant' : 'user';
            return `${roleLabel}: ${msg.content}`;
        })
            .join('\n\n');
        return [
            `System: ${systemPrompt}`,
            conversationHistory ? `\n\nConversation History:\n${conversationHistory}` : '',
            `\n\nHuman: ${currentMessage}\n\nAssistant:`
        ].filter(Boolean).join('');
    }
    static async buildSystemPrompt(session, toolManager) {
        const fileTreeContext = await toolManager.generateFileTreeContext();
        const toolInstructions = toolManager.generateToolInstructions();
        return SystemPromptComposer.compose({
            base: session.systemPrompt || 'You are a helpful AI assistant with access to file operations and tools.',
            fileTree: fileTreeContext,
            tools: toolInstructions,
            context: ''
        });
    }
    static generateMessageId() {
        return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
    }
}
export class ToolResponseHandler {
    static async integrateToolResponses(session, toolResponses, provider, toolManager) {
        const capabilities = PROVIDER_CAPABILITIES[provider];
        const xmlResponses = toolResponses
            .map(tr => toolManager.generateToolResponse(tr))
            .join('\n\n');
        if (capabilities?.supportsConversation) {
            // Add as internal user message for conversation providers
            const toolResponseMessage = {
                id: this.generateMessageId(),
                role: 'user',
                content: xmlResponses,
                timestamp: Date.now(),
                metadata: {
                    isToolResponse: true,
                    internal: true,
                    toolCallId: toolResponses[0]?.id
                }
            };
            session.messages.push(toolResponseMessage);
        }
        else {
            // For simple prompt providers, tool responses are visible context
            const toolContextMessage = {
                id: this.generateMessageId(),
                role: 'user',
                content: `Tool Results:\n${xmlResponses}`,
                timestamp: Date.now(),
                metadata: {
                    isToolResponse: true,
                    internal: false, // Visible in simple prompt providers
                    toolCallId: toolResponses[0]?.id
                }
            };
            session.messages.push(toolContextMessage);
        }
    }
    static generateMessageId() {
        return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
    }
}