@riotprompt/riotprompt 0.0.8 → 0.0.10

package/dist/conversation.js

@@ -0,0 +1,649 @@
+import { z } from 'zod';
+import { ContextManager } from './context-manager.js';
+import { ConversationLogger } from './conversation-logger.js';
+import { wrapLogger, DEFAULT_LOGGER } from './logger.js';
+import { MessageBuilder } from './message-builder.js';
+import { create } from './formatter.js';
+import { TokenBudgetManager } from './token-budget.js';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+// ===== SCHEMAS =====
+const ConversationBuilderConfigSchema = z.object({
+    model: z.string(),
+    formatter: z.any().optional(),
+    trackContext: z.boolean().optional().default(true),
+    deduplicateContext: z.boolean().optional().default(true)
+});
+// ===== CONVERSATION BUILDER =====
+/**
+ * ConversationBuilder manages multi-turn conversations with full lifecycle support.
+ *
+ * Features:
+ * - Initialize from RiotPrompt prompts
+ * - Add messages of any type (system, user, assistant, tool)
+ * - Handle tool calls and results
+ * - Inject dynamic context
+ * - Clone for parallel exploration
+ * - Serialize/deserialize for persistence
+ *
+ * @example
+ * ```typescript
+ * // Create from prompt
+ * const conversation = ConversationBuilder.create()
+ *   .fromPrompt(prompt, 'gpt-4o')
+ *   .build();
+ *
+ * // Add messages
+ * conversation.addUserMessage('Analyze this code');
+ *
+ * // Handle tool calls
+ * conversation.addAssistantWithToolCalls(null, toolCalls);
+ * conversation.addToolResult(toolCallId, result);
+ *
+ * // Export
+ * const messages = conversation.toMessages();
+ * ```
+ */ class ConversationBuilder {
+    /**
+     * Create a new ConversationBuilder instance
+     */ static create(config, logger) {
+        const defaultConfig = {
+            model: 'gpt-4o',
+            trackContext: true,
+            deduplicateContext: true,
+            ...config
+        };
+        return new ConversationBuilder(defaultConfig, logger);
+    }
+    /**
+     * Initialize conversation from a RiotPrompt prompt
+     */ fromPrompt(prompt, model) {
+        const targetModel = model || this.config.model;
+        this.logger.debug('Initializing from prompt', {
+            model: targetModel
+        });
+        // Use formatter (provided or create new one)
+        const formatter$1 = this.config.formatter || create();
+        const request = formatter$1.formatPrompt(targetModel, prompt);
+        // Add all messages from formatted request
+        request.messages.forEach((msg)=>{
+            this.state.messages.push(msg);
+        });
+        this.updateMetadata();
+        this.logger.debug('Initialized from prompt', {
+            messageCount: this.state.messages.length
+        });
+        return this;
+    }
+    /**
+     * Add a system message
+     */ addSystemMessage(content) {
+        this.logger.debug('Adding system message');
+        let messageContent;
+        if (typeof content === 'string') {
+            messageContent = content;
+        } else {
+            // Format section using formatter
+            const formatter$1 = this.config.formatter || create();
+            messageContent = formatter$1.format(content);
+        }
+        this.state.messages.push({
+            role: 'system',
+            content: messageContent
+        });
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add a user message (with automatic budget management)
+     */ addUserMessage(content) {
+        this.logger.debug('Adding user message');
+        let messageContent;
+        if (typeof content === 'string') {
+            messageContent = content;
+        } else {
+            // Format section using formatter
+            const formatter$1 = this.config.formatter || create();
+            messageContent = formatter$1.format(content);
+        }
+        const message = {
+            role: 'user',
+            content: messageContent
+        };
+        // Check budget if enabled
+        if (this.budgetManager) {
+            if (!this.budgetManager.canAddMessage(message, this.state.messages)) {
+                this.logger.warn('Budget exceeded, compressing conversation');
+                this.state.messages = this.budgetManager.compress(this.state.messages);
+                // Re-check after compression and warn if still over budget
+                if (!this.budgetManager.canAddMessage(message, this.state.messages)) {
+                    this.logger.warn('Token budget still exceeded after compression, adding message anyway');
+                // Note: We add the message anyway to maintain backward compatibility
+                // Consider setting onBudgetExceeded: 'error' in config if strict enforcement is needed
+                }
+            }
+        }
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add an assistant message
+     */ addAssistantMessage(content) {
+        this.logger.debug('Adding assistant message');
+        this.state.messages.push({
+            role: 'assistant',
+            content: content || ''
+        });
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add an assistant message with tool calls
+     */ addAssistantWithToolCalls(content, toolCalls) {
+        this.logger.debug('Adding assistant message with tool calls', {
+            toolCount: toolCalls.length
+        });
+        this.state.messages.push({
+            role: 'assistant',
+            content: content,
+            tool_calls: toolCalls
+        });
+        this.state.metadata.toolCallCount += toolCalls.length;
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add a tool result message
+     */ addToolResult(toolCallId, content, toolName) {
+        this.logger.debug('Adding tool result', {
+            toolCallId,
+            toolName
+        });
+        const message = {
+            role: 'tool',
+            tool_call_id: toolCallId,
+            content: content
+        };
+        if (toolName) {
+            message.name = toolName;
+        }
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Alias for addToolResult (more intuitive naming)
+     */ addToolMessage(toolCallId, content, toolName) {
+        return this.addToolResult(toolCallId, content, toolName);
+    }
+    /**
+     * Inject context into the conversation with advanced options
+     *
+     * @param context - Array of content items to inject
+     * @param options - Injection options (position, format, deduplication, etc.)
+     */ injectContext(context, options) {
+        var _this_config_deduplicateContext;
+        const opts = {
+            position: 'end',
+            format: 'structured',
+            deduplicate: (_this_config_deduplicateContext = this.config.deduplicateContext) !== null && _this_config_deduplicateContext !== void 0 ? _this_config_deduplicateContext : true,
+            deduplicateBy: 'id',
+            priority: 'medium',
+            weight: 1.0,
+            category: undefined,
+            source: undefined,
+            ...options
+        };
+        this.logger.debug('Injecting context', {
+            itemCount: context.length,
+            options: opts
+        });
+        // Filter out duplicates if enabled
+        const itemsToAdd = [];
+        for (const item of context){
+            const enrichedItem = {
+                ...item,
+                priority: item.priority || opts.priority,
+                weight: item.weight || opts.weight,
+                category: item.category || opts.category,
+                source: item.source || opts.source,
+                timestamp: item.timestamp || new Date()
+            };
+            // Check deduplication
+            if (opts.deduplicate) {
+                let skip = false;
+                switch(opts.deduplicateBy){
+                    case 'id':
+                        if (enrichedItem.id && this.state.contextManager.hasContext(enrichedItem.id)) {
+                            this.logger.debug('Skipping duplicate context by ID', {
+                                id: enrichedItem.id
+                            });
+                            skip = true;
+                        }
+                        break;
+                    case 'hash':
+                        if (this.state.contextManager.hasContentHash(enrichedItem.content)) {
+                            this.logger.debug('Skipping duplicate context by hash');
+                            skip = true;
+                        }
+                        break;
+                    case 'content':
+                        if (this.state.contextManager.hasSimilarContent(enrichedItem.content)) {
+                            this.logger.debug('Skipping duplicate context by content');
+                            skip = true;
+                        }
+                        break;
+                }
+                if (skip) {
+                    continue;
+                }
+            }
+            itemsToAdd.push(enrichedItem);
+        }
+        // Only proceed if we have items to add
+        if (itemsToAdd.length === 0) {
+            return this;
+        }
+        // Calculate position
+        const position = this.calculatePosition(opts.position);
+        // Format and inject
+        for(let i = 0; i < itemsToAdd.length; i++){
+            const item = itemsToAdd[i];
+            const formatted = this.formatContextItem(item, opts.format);
+            const contextMessage = {
+                role: 'user',
+                content: formatted
+            };
+            // Each item is inserted at position + index to maintain order
+            const actualPosition = position + i;
+            this.state.messages.splice(actualPosition, 0, contextMessage);
+            // Track in context manager with correct position
+            this.state.contextManager.track(item, actualPosition);
+        }
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Inject system-level context
+     */ injectSystemContext(context) {
+        this.logger.debug('Injecting system context');
+        let messageContent;
+        if (typeof context === 'string') {
+            messageContent = context;
+        } else {
+            const formatter$1 = this.config.formatter || create();
+            messageContent = formatter$1.format(context);
+        }
+        this.state.messages.push({
+            role: 'system',
+            content: messageContent
+        });
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Get the number of messages in the conversation
+     */ getMessageCount() {
+        return this.state.messages.length;
+    }
+    /**
+     * Get the last message in the conversation
+     */ getLastMessage() {
+        return this.state.messages[this.state.messages.length - 1];
+    }
+    /**
+     * Get all messages
+     */ getMessages() {
+        return [
+            ...this.state.messages
+        ];
+    }
+    /**
+     * Check if conversation has any tool calls
+     */ hasToolCalls() {
+        return this.state.metadata.toolCallCount > 0;
+    }
+    /**
+     * Get conversation metadata
+     */ getMetadata() {
+        return {
+            ...this.state.metadata
+        };
+    }
+    /**
+     * Export messages in OpenAI format (deep copy to prevent shared state)
+     */ toMessages() {
+        return this.state.messages.map((msg)=>({
+                ...msg,
+                tool_calls: msg.tool_calls ? msg.tool_calls.map((tc)=>({
+                        ...tc,
+                        function: {
+                            ...tc.function
+                        }
+                    })) : undefined
+            }));
+    }
+    /**
+     * Serialize conversation to JSON
+     */ toJSON() {
+        const serialized = {
+            messages: this.state.messages,
+            metadata: {
+                ...this.state.metadata,
+                created: this.state.metadata.created.toISOString(),
+                lastModified: this.state.metadata.lastModified.toISOString()
+            },
+            contextProvided: Array.from(this.state.contextProvided)
+        };
+        return JSON.stringify(serialized, null, 2);
+    }
+    /**
+     * Restore conversation from JSON
+     */ static fromJSON(json, config, logger) {
+        const parsed = JSON.parse(json);
+        const builder = ConversationBuilder.create({
+            model: parsed.metadata.model,
+            ...config
+        }, logger);
+        // Restore state
+        builder.state.messages = parsed.messages;
+        builder.state.metadata = {
+            ...parsed.metadata,
+            created: new Date(parsed.metadata.created),
+            lastModified: new Date(parsed.metadata.lastModified)
+        };
+        builder.state.contextProvided = new Set(parsed.contextProvided);
+        return builder;
+    }
+    /**
+     * Clone the conversation for parallel exploration (deep copy to prevent shared state)
+     */ clone() {
+        this.logger.debug('Cloning conversation');
+        const cloned = ConversationBuilder.create({
+            ...this.config
+        }, this.logger);
+        // Deep copy state (note: contextManager is already created in constructor)
+        cloned.state.messages = this.state.messages.map((msg)=>({
+                ...msg,
+                tool_calls: msg.tool_calls ? msg.tool_calls.map((tc)=>({
+                        ...tc,
+                        function: {
+                            ...tc.function
+                        }
+                    })) : undefined
+            }));
+        cloned.state.metadata = {
+            ...this.state.metadata
+        };
+        cloned.state.contextProvided = new Set(this.state.contextProvided);
+        // Copy context manager state
+        const allContext = this.state.contextManager.getAll();
+        allContext.forEach((item)=>{
+            cloned.state.contextManager.track(item, item.position);
+        });
+        return cloned;
+    }
+    /**
+     * Truncate conversation to last N messages
+     */ truncate(maxMessages) {
+        this.logger.debug('Truncating conversation', {
+            maxMessages,
+            current: this.state.messages.length
+        });
+        if (this.state.messages.length > maxMessages) {
+            this.state.messages = this.state.messages.slice(-maxMessages);
+            this.updateMetadata();
+        }
+        return this;
+    }
+    /**
+     * Remove all messages of a specific type
+     */ removeMessagesOfType(role) {
+        this.logger.debug('Removing messages of type', {
+            role
+        });
+        this.state.messages = this.state.messages.filter((msg)=>msg.role !== role);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Get the context manager
+     */ getContextManager() {
+        return this.state.contextManager;
+    }
+    /**
+     * Get conversation state (for conditional injection)
+     */ getState() {
+        return {
+            messages: [
+                ...this.state.messages
+            ],
+            metadata: {
+                ...this.state.metadata
+            },
+            contextProvided: new Set(this.state.contextProvided),
+            contextManager: this.state.contextManager
+        };
+    }
+    // ===== SEMANTIC MESSAGE METHODS (Feature 5) =====
+    /**
+     * Add a system message using semantic builder
+     */ asSystem(content) {
+        const message = MessageBuilder.system(this.logger).withContent(content).withFormatter(this.config.formatter || create()).buildForModel(this.config.model);
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add a user message using semantic builder
+     */ asUser(content) {
+        const message = MessageBuilder.user(this.logger).withContent(content).withFormatter(this.config.formatter || create()).buildForModel(this.config.model);
+        // Check budget if enabled
+        if (this.budgetManager) {
+            if (!this.budgetManager.canAddMessage(message, this.state.messages)) {
+                this.logger.warn('Budget exceeded, compressing conversation');
+                this.state.messages = this.budgetManager.compress(this.state.messages);
+            }
+        }
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add an assistant message using semantic builder
+     */ asAssistant(content, toolCalls) {
+        const builder = MessageBuilder.assistant(this.logger).withFormatter(this.config.formatter || create());
+        if (content) {
+            builder.withContent(content);
+        }
+        if (toolCalls) {
+            builder.withToolCalls(toolCalls);
+        }
+        const message = builder.buildForModel(this.config.model);
+        if (toolCalls) {
+            this.state.metadata.toolCallCount += toolCalls.length;
+        }
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Add a tool result message using semantic builder
+     */ asTool(callId, result, metadata) {
+        const builder = MessageBuilder.tool(callId, this.logger).withResult(result);
+        if (metadata) {
+            builder.withMetadata(metadata);
+        }
+        const message = builder.buildForModel(this.config.model);
+        this.state.messages.push(message);
+        this.updateMetadata();
+        return this;
+    }
+    /**
+     * Configure token budget
+     */ withTokenBudget(config) {
+        this.logger.debug('Configuring token budget', {
+            max: config.max
+        });
+        this.budgetManager = new TokenBudgetManager(config, this.config.model, this.logger);
+        return this;
+    }
+    /**
+     * Configure conversation logging
+     */ withLogging(config) {
+        this.logger.debug('Configuring conversation logging');
+        this.conversationLogger = new ConversationLogger(config, this.logger);
+        this.conversationLogger.onConversationStart({
+            model: this.config.model,
+            startTime: new Date()
+        });
+        return this;
+    }
+    /**
+     * Save conversation log
+     */ async saveLog() {
+        if (!this.conversationLogger) {
+            throw new Error('Logging not enabled. Call withLogging() first.');
+        }
+        this.conversationLogger.onConversationEnd({
+            totalMessages: this.state.messages.length,
+            toolCallsExecuted: this.state.metadata.toolCallCount,
+            iterations: 0,
+            success: true
+        });
+        return await this.conversationLogger.save();
+    }
+    /**
+     * Get current token usage
+     */ getTokenUsage() {
+        if (!this.budgetManager) {
+            return {
+                used: 0,
+                max: Infinity,
+                remaining: Infinity,
+                percentage: 0
+            };
+        }
+        return this.budgetManager.getCurrentUsage(this.state.messages);
+    }
+    /**
+     * Manually compress conversation
+     */ compress(_strategy) {
+        if (this.budgetManager) {
+            this.state.messages = this.budgetManager.compress(this.state.messages);
+        }
+        return this;
+    }
+    /**
+     * Build and return the builder (for fluent API compatibility)
+     */ build() {
+        return this;
+    }
+    /**
+     * Calculate position for context injection
+     *
+     * Positions:
+     * - 'end': After all messages
+     * - 'before-last': Before the last message
+     * - 'after-system': After the LAST system message (useful for models with multiple system messages)
+     * - number: Specific index (clamped to valid range)
+     */ calculatePosition(position) {
+        if (typeof position === 'number') {
+            return Math.max(0, Math.min(position, this.state.messages.length));
+        }
+        switch(position){
+            case 'end':
+                return this.state.messages.length;
+            case 'before-last':
+                return Math.max(0, this.state.messages.length - 1);
+            case 'after-system':
+                {
+                    // Find last system message (uses reverse search to find most recent system message)
+                    let lastSystemIdx = -1;
+                    for(let i = this.state.messages.length - 1; i >= 0; i--){
+                        if (this.state.messages[i].role === 'system') {
+                            lastSystemIdx = i;
+                            break;
+                        }
+                    }
+                    return lastSystemIdx >= 0 ? lastSystemIdx + 1 : 0;
+                }
+            default:
+                return this.state.messages.length;
+        }
+    }
+    /**
+     * Format context item based on format option
+     */ formatContextItem(item, format) {
+        switch(format){
+            case 'structured':
+                {
+                    let result = `## ${item.title || 'Context'}\n\n${item.content}`;
+                    // Add metadata if available
+                    const metadata = [];
+                    if (item.source) {
+                        metadata.push(`Source: ${item.source}`);
+                    }
+                    if (item.timestamp) {
+                        metadata.push(`Timestamp: ${item.timestamp.toISOString()}`);
+                    }
+                    if (metadata.length > 0) {
+                        result += `\n\n_${metadata.join(' | ')}_`;
+                    }
+                    return result;
+                }
+            case 'inline':
+                return `Note: ${item.title ? `${item.title}: ` : ''}${item.content}`;
+            case 'reference':
+                return `[Context Reference: ${item.id || 'unknown'}]\nSee attached context${item.title ? ` for ${item.title}` : ''}`;
+            default:
+                return item.content;
+        }
+    }
+    /**
+     * Update metadata after state changes
+     */ updateMetadata() {
+        this.state.metadata.messageCount = this.state.messages.length;
+        this.state.metadata.lastModified = new Date();
+    }
+    constructor(config, logger){
+        _define_property(this, "state", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "budgetManager", void 0);
+        _define_property(this, "conversationLogger", void 0);
+        this.config = ConversationBuilderConfigSchema.parse(config);
+        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ConversationBuilder');
+        this.state = {
+            messages: [],
+            metadata: {
+                model: this.config.model,
+                created: new Date(),
+                lastModified: new Date(),
+                messageCount: 0,
+                toolCallCount: 0
+            },
+            contextProvided: new Set(),
+            contextManager: new ContextManager(logger)
+        };
+        this.logger.debug('Created ConversationBuilder', {
+            model: this.config.model
+        });
+    }
+}
+
+export { ConversationBuilder, ConversationBuilder as default };
+//# sourceMappingURL=conversation.js.map