@riotprompt/riotprompt 0.0.9 → 0.0.10

package/dist/riotprompt.cjs

@@ -128,7 +128,7 @@ const create$8 = (options = {})=>{
         };
         if (Array.isArray(item)) {
             item.forEach((item)=>{
-                append(item);
+                append(item, options); // Propagate options to array items
             });
         } else {
             if (typeof item === 'string') {
@@ -147,7 +147,7 @@ const create$8 = (options = {})=>{
         };
         if (Array.isArray(item)) {
             item.forEach((item)=>{
-                prepend(item);
+                prepend(item, options); // Propagate options to array items
             });
         } else {
             if (typeof item === 'string') {
@@ -166,7 +166,7 @@ const create$8 = (options = {})=>{
         };
         if (Array.isArray(item)) {
             item.forEach((item)=>{
-                insert(index, item);
+                insert(index, item, options); // Propagate options to array items
             });
         } else {
             if (typeof item === 'string') {
@@ -243,7 +243,6 @@ const create$6 = ({ persona, instructions, contents, contexts })=>{
 
 const DEFAULT_CHARACTER_ENCODING = "utf8";
 const LIBRARY_NAME = "riotprompt";
-const DEFAULT_PERSONA_ROLE = "developer";
 const DEFAULT_IGNORE_PATTERNS = [
     "^\\..*",
     "\\.(jpg|jpeg|png|gif|bmp|svg|webp|ico)$",
@@ -262,29 +261,6 @@ const DEFAULT_FORMAT_OPTIONS = {
     sectionDepth: 0
 };
 
-const getPersonaRole = (model)=>{
-    if (model === "gpt-4o" || model === "gpt-4o-mini") {
-        return "system";
-    }
-    return DEFAULT_PERSONA_ROLE;
-};
-const createRequest = (model)=>{
-    const messages = [];
-    return {
-        model,
-        messages,
-        addMessage: (message)=>{
-            messages.push(message);
-        }
-    };
-};
-
-const chat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-    __proto__: null,
-    createRequest,
-    getPersonaRole
-}, Symbol.toStringTag, { value: 'Module' }));
-
 const DEFAULT_LOGGER = {
     name: 'default',
     debug: (message, ...args)=>console.debug(message, ...args),
@@ -329,6 +305,227 @@ const wrapLogger = (toWrap, name)=>{
     };
 };
 
+function _define_property$8(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;
+}
+/**
+ * Model registry for managing model configurations
+ */ class ModelRegistry {
+    /**
+     * Register default model configurations
+     */ registerDefaults() {
+        // GPT-4 family (uses 'system' role)
+        this.register({
+            pattern: /^gpt-4/i,
+            personaRole: 'system',
+            encoding: 'gpt-4o',
+            supportsToolCalls: true,
+            family: 'gpt-4',
+            description: 'GPT-4 family models'
+        });
+        // O-series models (uses 'developer' role)
+        this.register({
+            pattern: /^o\d+/i,
+            personaRole: 'developer',
+            encoding: 'gpt-4o',
+            supportsToolCalls: true,
+            family: 'o-series',
+            description: 'O-series reasoning models'
+        });
+        // Claude family (uses 'system' role)
+        this.register({
+            pattern: /^claude/i,
+            personaRole: 'system',
+            encoding: 'cl100k_base',
+            supportsToolCalls: true,
+            family: 'claude',
+            description: 'Claude family models'
+        });
+        // Default fallback
+        this.register({
+            pattern: /.*/,
+            personaRole: 'system',
+            encoding: 'gpt-4o',
+            supportsToolCalls: true,
+            family: 'unknown',
+            description: 'Default fallback configuration'
+        });
+        this.logger.debug('Registered default model configurations');
+    }
+    /**
+     * Register a model configuration
+     * Configs are checked in registration order (first match wins)
+     */ register(config) {
+        var _config_pattern;
+        // Validate config
+        if (!config.pattern && !config.exactMatch) {
+            throw new Error('Model config must have either pattern or exactMatch');
+        }
+        this.configs.push(config);
+        this.cache.clear(); // Clear cache when new config is added
+        this.logger.debug('Registered model config', {
+            family: config.family,
+            pattern: (_config_pattern = config.pattern) === null || _config_pattern === void 0 ? void 0 : _config_pattern.source,
+            exactMatch: config.exactMatch
+        });
+    }
+    /**
+     * Get configuration for a model
+     */ getConfig(model) {
+        // Check cache first
+        if (this.cache.has(model)) {
+            return this.cache.get(model);
+        }
+        // Find matching config (first match wins)
+        for (const config of this.configs){
+            if (config.exactMatch && config.exactMatch === model) {
+                this.cache.set(model, config);
+                return config;
+            }
+            if (config.pattern && config.pattern.test(model)) {
+                this.cache.set(model, config);
+                return config;
+            }
+        }
+        // Should never happen due to default fallback, but just in case
+        throw new Error(`No configuration found for model: ${model}`);
+    }
+    /**
+     * Get persona role for a model
+     */ getPersonaRole(model) {
+        return this.getConfig(model).personaRole;
+    }
+    /**
+     * Get tokenizer encoding for a model
+     */ getEncoding(model) {
+        return this.getConfig(model).encoding;
+    }
+    /**
+     * Check if model supports tool calls
+     */ supportsToolCalls(model) {
+        var _this_getConfig_supportsToolCalls;
+        return (_this_getConfig_supportsToolCalls = this.getConfig(model).supportsToolCalls) !== null && _this_getConfig_supportsToolCalls !== void 0 ? _this_getConfig_supportsToolCalls : true;
+    }
+    /**
+     * Get model family
+     */ getFamily(model) {
+        return this.getConfig(model).family;
+    }
+    /**
+     * Clear all registered configs and reset to defaults
+     */ reset() {
+        this.configs = [];
+        this.cache.clear();
+        this.registerDefaults();
+        this.logger.debug('Reset model configurations to defaults');
+    }
+    /**
+     * Clear cache (useful if configs are modified)
+     */ clearCache() {
+        this.cache.clear();
+        this.logger.debug('Cleared model configuration cache');
+    }
+    /**
+     * Get all registered configurations
+     */ getAllConfigs() {
+        return [
+            ...this.configs
+        ];
+    }
+    constructor(logger){
+        _define_property$8(this, "configs", void 0);
+        _define_property$8(this, "cache", void 0);
+        _define_property$8(this, "logger", void 0);
+        this.configs = [];
+        this.cache = new Map();
+        this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ModelRegistry');
+        // Register default configurations
+        this.registerDefaults();
+    }
+}
+// Global registry instance
+let globalRegistry = null;
+/**
+ * Get the global model registry
+ */ function getModelRegistry(logger) {
+    if (!globalRegistry) {
+        globalRegistry = new ModelRegistry(logger);
+    }
+    return globalRegistry;
+}
+/**
+ * Reset the global registry (useful for testing)
+ */ function resetModelRegistry() {
+    globalRegistry = null;
+}
+/**
+ * Helper functions using global registry
+ */ function getPersonaRole$1(model) {
+    return getModelRegistry().getPersonaRole(model);
+}
+function getEncoding(model) {
+    return getModelRegistry().getEncoding(model);
+}
+function supportsToolCalls(model) {
+    return getModelRegistry().supportsToolCalls(model);
+}
+function getModelFamily(model) {
+    return getModelRegistry().getFamily(model);
+}
+/**
+ * Configure a custom model
+ *
+ * @example
+ * ```typescript
+ * // Add support for a new model family
+ * configureModel({
+ *   pattern: /^gemini/i,
+ *   personaRole: 'system',
+ *   encoding: 'cl100k_base',
+ *   family: 'gemini'
+ * });
+ *
+ * // Add specific model override
+ * configureModel({
+ *   exactMatch: 'custom-model-v1',
+ *   personaRole: 'developer',
+ *   encoding: 'gpt-4o'
+ * });
+ * ```
+ */ function configureModel(config) {
+    getModelRegistry().register(config);
+}
+
+const getPersonaRole = (model)=>{
+    return getPersonaRole$1(model);
+};
+const createRequest = (model)=>{
+    const messages = [];
+    return {
+        model,
+        messages,
+        addMessage: (message)=>{
+            messages.push(message);
+        }
+    };
+};
+
+const chat = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    createRequest,
+    getPersonaRole
+}, Symbol.toStringTag, { value: 'Module' }));
+
 const clean = (obj)=>{
     return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
 };
@@ -343,7 +540,7 @@ const stringifyJSON = function(obj, visited = new Set()) {
         return '"(circular)"';
     } else if (Array.isArray(obj)) {
         //check for empty array
-        if (obj[0] === undefined) return '[]';
+        if (obj.length === 0) return '[]';
         else {
             // Add array to visited before processing its elements
             visited.add(obj);
@@ -807,13 +1004,13 @@ const create$4 = (parserOptions)=>{
             });
         } catch (error) {
             // Log the error or handle it appropriately
-            logger.error(`Error reading or parsing file with marked at ${filePath}:`, error);
-            throw new Error(`Failed to parse instructions from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+            logger.error(`Error reading or parsing file at ${filePath}:`, error);
+            throw new Error(`Failed to parse content from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
         }
     };
     /**
      * Reads Markdown content and parses it into a single Section.
-     * 
+     *
      * - If the content starts with a heading, that becomes the title of the returned Section
      * - If no heading at the start, creates a Section with no title
      * - Headers within the content create nested sections based on their depth
@@ -1017,7 +1214,7 @@ const create$2 = (loaderOptions)=>{
     };
     /**
      * Loads context from the provided directories and returns instruction sections
-     * 
+     *
      * @param contextDirectories Directories containing context files
      * @returns Array of instruction sections loaded from context directories
      */ const load = async (contextDirectories = [], options = {})=>{
@@ -1069,8 +1266,22 @@ const create$2 = (loaderOptions)=>{
                 }
                 // Get all other files in the directory
                 const files = await storage.listFiles(contextDir);
-                const ignorePatternsRegex = ignorePatterns.map((pattern)=>new RegExp(pattern, 'i'));
-                const filteredFiles = files.filter((file)=>!ignorePatternsRegex.some((regex)=>regex.test(file)));
+                const ignorePatternsRegex = ignorePatterns.map((pattern)=>{
+                    try {
+                        return new RegExp(pattern, 'i');
+                    } catch (error) {
+                        logger.error(`Invalid ignore pattern: ${pattern}`, {
+                            error
+                        });
+                        // Return a pattern that matches nothing
+                        return /(?!)/; // Negative lookahead that always fails
+                    }
+                });
+                const filteredFiles = files.filter((file)=>{
+                    const fullPath = path.join(contextDir, file);
+                    // Test against both filename and full path for flexibility
+                    return !ignorePatternsRegex.some((regex)=>regex.test(file) || regex.test(fullPath));
+                });
                 for (const file of filteredFiles){
                     // Skip the context.md file as it's already processed
                     if (file === 'context.md') continue;
@@ -1098,6 +1309,7 @@ const create$2 = (loaderOptions)=>{
                             ...sectionOptions
                         });
                         // Add this file section to the main context section
+                        // Type is correct - Section.add() accepts Section<T>
                         mainContextSection.add(fileSection, {
                             ...sectionOptions
                         });
@@ -1213,7 +1425,11 @@ const create$1 = (overrideOptions = {})=>{
             finalSection = finalSection.prepend(prepend);
         }
         // Apply appends in reverse order (furthest layers first, then closest)
-        for (const append of appends.reverse()){
+        // Create a copy to avoid mutating the original array
+        const reversedAppends = [
+            ...appends
+        ].reverse();
+        for (const append of reversedAppends){
             logger.silly('Append found, adding to content from file %s', append);
             finalSection = finalSection.append(append);
         }
@@ -1422,10 +1638,17 @@ function _define_property$7(obj, key, value) {
  * ```
  */ class ContextManager {
     /**
-     * Track a context item
+     * Track a context item (with deduplication by content hash for items without ID)
      */ track(item, position) {
-        const id = item.id || this.generateId();
         const hash = this.hashContent(item.content);
+        // If item has no ID and we already have this content hash, skip tracking
+        if (!item.id && this.hashes.has(hash)) {
+            this.logger.debug('Skipping duplicate context item by hash', {
+                hash
+            });
+            return;
+        }
+        const id = item.id || this.generateId();
         const trackedItem = {
             ...item,
             id,
@@ -1456,7 +1679,16 @@ function _define_property$7(obj, key, value) {
     }
     /**
      * Check if similar content exists (fuzzy match)
-     */ hasSimilarContent(content) {
+     * Uses similarity threshold to avoid overly aggressive deduplication
+     */ hasSimilarContent(content, similarityThreshold = 0.9) {
+        // Warn if checking against a large number of items (performance consideration)
+        const MAX_ITEMS_WARNING = 1000;
+        if (this.items.size > MAX_ITEMS_WARNING) {
+            this.logger.warn('Large number of context items, similarity check may be slow', {
+                count: this.items.size,
+                threshold: MAX_ITEMS_WARNING
+            });
+        }
         const normalized = this.normalizeContent(content);
         for (const item of this.items.values()){
             const itemNormalized = this.normalizeContent(item.content || '');
@@ -1464,9 +1696,16 @@ function _define_property$7(obj, key, value) {
             if (normalized === itemNormalized) {
                 return true;
             }
-            // Substring match (one contains the other)
-            if (normalized.includes(itemNormalized) || itemNormalized.includes(normalized)) {
-                return true;
+            // Calculate similarity ratio (Jaccard-like)
+            const longer = normalized.length > itemNormalized.length ? normalized : itemNormalized;
+            const shorter = normalized.length <= itemNormalized.length ? normalized : itemNormalized;
+            // Only consider substring match if the shorter is at least 90% of longer
+            const lengthRatio = shorter.length / longer.length;
+            if (lengthRatio >= similarityThreshold) {
+                // Check if one is contained in the other
+                if (longer.includes(shorter)) {
+                    return true;
+                }
             }
         }
         return false;
@@ -1638,6 +1877,8 @@ function _define_property$6(obj, key, value) {
             ...metadata,
             startTime: this.startTime
         };
+        // Reset cached output path to prevent file collision if logger is reused
+        this.cachedOutputPath = undefined;
         this.logger.debug('Conversation logging started', {
             id: this.conversationId
         });
@@ -1660,9 +1901,21 @@ function _define_property$6(obj, key, value) {
             metadata
         };
         this.messages.push(loggedMessage);
-        // For JSONL format, append immediately
+        // For JSONL format, append immediately with write queue
         if (this.config.format === 'jsonl') {
-            this.appendToJSONL(loggedMessage).catch(this.config.onError);
+            this.writeQueue = this.writeQueue.then(()=>this.appendToJSONL(loggedMessage)).catch((error)=>{
+                this.logger.error('Failed to write JSONL message', {
+                    error
+                });
+                try {
+                    var _this_config_onError, _this_config;
+                    (_this_config_onError = (_this_config = this.config).onError) === null || _this_config_onError === void 0 ? void 0 : _this_config_onError.call(_this_config, error);
+                } catch (callbackError) {
+                    this.logger.error('onError callback failed', {
+                        callbackError
+                    });
+                }
+            });
         }
     }
     /**
@@ -1744,8 +1997,11 @@ function _define_property$6(obj, key, value) {
         return `conv-${timestamp}-${random}`;
     }
     /**
-     * Get output file path
+     * Get output file path (cached for JSONL to avoid recalculation)
      */ async getOutputPath() {
+        if (this.cachedOutputPath) {
+            return this.cachedOutputPath;
+        }
         const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
         const filename = this.config.filenameTemplate.replace('{timestamp}', timestamp).replace('{id}', this.conversationId).replace('{template}', this.metadata.template || 'default');
         const ext = this.config.format === 'markdown' ? '.md' : '.json';
@@ -1754,6 +2010,10 @@ function _define_property$6(obj, key, value) {
         await fs.mkdir(path.dirname(fullPath), {
             recursive: true
         });
+        // Cache path for JSONL format to ensure consistent file writes
+        if (this.config.format === 'jsonl') {
+            this.cachedOutputPath = fullPath;
+        }
         return fullPath;
     }
     /**
@@ -1844,6 +2104,8 @@ function _define_property$6(obj, key, value) {
         _define_property$6(this, "startTime", void 0);
         _define_property$6(this, "logger", void 0);
         _define_property$6(this, "messageIndex", void 0);
+        _define_property$6(this, "cachedOutputPath", void 0);
+        _define_property$6(this, "writeQueue", Promise.resolve());
         this.config = {
             outputPath: 'logs/conversations',
             format: 'json',
@@ -1960,12 +2222,26 @@ function _define_property$6(obj, key, value) {
         for (const msg of this.conversation.messages){
             if (msg.tool_calls) {
                 for (const call of msg.tool_calls){
+                    // Parse arguments with error handling
+                    let parsedArgs;
+                    try {
+                        parsedArgs = JSON.parse(call.function.arguments);
+                    } catch (error) {
+                        this.logger.warn('Failed to parse tool call arguments', {
+                            callId: call.id,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                        parsedArgs = {
+                            __parse_error: true,
+                            raw: call.function.arguments
+                        };
+                    }
                     toolCalls.push({
                         callId: call.id,
                         toolName: call.function.name,
                         timestamp: msg.timestamp,
                         iteration: 0,
-                        arguments: JSON.parse(call.function.arguments),
+                        arguments: parsedArgs,
                         result: null,
                         duration: 0,
                         success: true
@@ -2214,8 +2490,9 @@ function _define_property$5(obj, key, value) {
         const message = this.build();
         // Handle model-specific role requirements
         if (this.semanticRole === 'system') {
-            // O1 models use 'developer' instead of 'system'
-            if (model.startsWith('o1') || model.startsWith('o3') || model === 'o1-pro') {
+            // Use model registry to determine correct role
+            const personaRole = getPersonaRole$1(model);
+            if (personaRole === 'developer') {
                 message.role = 'developer';
             }
         }
@@ -2385,19 +2662,16 @@ function _define_property$4(obj, key, value) {
         return Math.max(500, Math.floor(inputTokens * 0.2));
     }
     /**
-     * Map RiotPrompt model to Tiktoken model
+     * Map RiotPrompt model to Tiktoken model using model registry
      */ mapToTiktokenModel(model) {
-        switch(model){
+        const encoding = getEncoding(model);
+        // Map our encoding types to tiktoken models
+        switch(encoding){
             case 'gpt-4o':
-            case 'gpt-4o-mini':
-                return 'gpt-4o';
-            case 'o1-preview':
-            case 'o1-mini':
-            case 'o1':
-            case 'o3-mini':
-            case 'o1-pro':
-                // O1 models use gpt-4o tokenization
+            case 'o200k_base':
                 return 'gpt-4o';
+            case 'cl100k_base':
+                return 'gpt-3.5-turbo';
             default:
                 return 'gpt-4o';
         }
@@ -2564,16 +2838,16 @@ function _define_property$4(obj, key, value) {
         return kept.map((item)=>item.message);
     }
     /**
-     * Compress using FIFO (remove oldest first)
+     * Compress using FIFO (remove oldest first) - optimized with Set
      */ compressFIFO(messages, targetTokens) {
         var _this_config_preserveRecent;
-        const preserved = [];
+        const preservedSet = new Set();
         let totalTokens = 0;
         // Always preserve system messages if configured
         const systemMessages = messages.filter((m)=>m.role === 'system');
         if (this.config.preserveSystem) {
             for (const msg of systemMessages){
-                preserved.push(msg);
+                preservedSet.add(msg);
                 totalTokens += this.counter.countMessage(msg);
             }
         }
@@ -2581,28 +2855,28 @@ function _define_property$4(obj, key, value) {
         const recentCount = (_this_config_preserveRecent = this.config.preserveRecent) !== null && _this_config_preserveRecent !== void 0 ? _this_config_preserveRecent : 3;
         const recentMessages = messages.slice(-recentCount).filter((m)=>m.role !== 'system');
         for (const msg of recentMessages){
-            if (!preserved.includes(msg)) {
+            if (!preservedSet.has(msg)) {
                 const tokens = this.counter.countMessage(msg);
                 if (totalTokens + tokens <= targetTokens) {
-                    preserved.push(msg);
+                    preservedSet.add(msg);
                     totalTokens += tokens;
                 }
             }
         }
         // Add older messages if space available
-        const otherMessages = messages.filter((m)=>!preserved.includes(m) && m.role !== 'system');
+        const otherMessages = messages.filter((m)=>!preservedSet.has(m) && m.role !== 'system');
         for(let i = otherMessages.length - 1; i >= 0; i--){
             const msg = otherMessages[i];
             const tokens = this.counter.countMessage(msg);
             if (totalTokens + tokens <= targetTokens) {
-                preserved.unshift(msg);
+                preservedSet.add(msg);
                 totalTokens += tokens;
             } else {
                 break;
             }
         }
-        // Sort to maintain conversation order
-        return messages.filter((m)=>preserved.includes(m));
+        // Sort to maintain conversation order - use Set for O(1) lookup
+        return messages.filter((m)=>preservedSet.has(m));
     }
     /**
      * Adaptive compression based on conversation phase
@@ -2614,13 +2888,12 @@ function _define_property$4(obj, key, value) {
         }
         // Mid phase: moderate compression
         if (messageCount <= 15) {
-            // Use FIFO but preserve more recent messages
-            const modifiedConfig = {
-                ...this.config,
-                preserveRecent: 5
-            };
-            const tempManager = new TokenBudgetManager(modifiedConfig, 'gpt-4o', this.logger);
-            return tempManager.compressFIFO(messages, targetTokens);
+            // Temporarily modify preserveRecent, then restore
+            const originalPreserveRecent = this.config.preserveRecent;
+            this.config.preserveRecent = 5;
+            const result = this.compressFIFO(messages, targetTokens);
+            this.config.preserveRecent = originalPreserveRecent;
+            return result;
         }
         // Late phase: aggressive compression (priority-based)
         return this.compressByPriority(messages, targetTokens);
@@ -2809,6 +3082,12 @@ const ConversationBuilderConfigSchema = zod.z.object({
             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);
@@ -2936,15 +3215,18 @@ const ConversationBuilderConfigSchema = zod.z.object({
         // Calculate position
         const position = this.calculatePosition(opts.position);
         // Format and inject
-        for (const item of itemsToAdd){
+        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
             };
-            this.state.messages.splice(position, 0, contextMessage);
-            // Track in context manager
-            this.state.contextManager.track(item, position);
+            // 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;
@@ -2997,10 +3279,16 @@ const ConversationBuilderConfigSchema = zod.z.object({
         };
     }
     /**
-     * Export messages in OpenAI format
+     * Export messages in OpenAI format (deep copy to prevent shared state)
      */ toMessages() {
         return this.state.messages.map((msg)=>({
-                ...msg
+                ...msg,
+                tool_calls: msg.tool_calls ? msg.tool_calls.map((tc)=>({
+                        ...tc,
+                        function: {
+                            ...tc.function
+                        }
+                    })) : undefined
             }));
     }
     /**
@@ -3036,7 +3324,7 @@ const ConversationBuilderConfigSchema = zod.z.object({
         return builder;
     }
     /**
-     * Clone the conversation for parallel exploration
+     * Clone the conversation for parallel exploration (deep copy to prevent shared state)
      */ clone() {
         this.logger.debug('Cloning conversation');
         const cloned = ConversationBuilder.create({
@@ -3044,7 +3332,13 @@ const ConversationBuilderConfigSchema = zod.z.object({
         }, this.logger);
         // Deep copy state (note: contextManager is already created in constructor)
         cloned.state.messages = this.state.messages.map((msg)=>({
-                ...msg
+                ...msg,
+                tool_calls: msg.tool_calls ? msg.tool_calls.map((tc)=>({
+                        ...tc,
+                        function: {
+                            ...tc.function
+                        }
+                    })) : undefined
             }));
         cloned.state.metadata = {
             ...this.state.metadata
@@ -3215,6 +3509,12 @@ const ConversationBuilderConfigSchema = zod.z.object({
     }
     /**
      * 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));
@@ -3226,7 +3526,7 @@ const ConversationBuilderConfigSchema = zod.z.object({
                 return Math.max(0, this.state.messages.length - 1);
             case 'after-system':
                 {
-                    // Find last system message (reverse search for compatibility)
+                    // 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') {
@@ -3682,10 +3982,10 @@ function _define_property$1(obj, key, value) {
         // Calculate token usage if model provided
         let tokenUsage;
         if (model) {
+            let counter;
             try {
-                const counter = new TokenCounter(model);
+                counter = new TokenCounter(model);
                 const total = counter.countConversation(messages);
-                counter.dispose();
                 tokenUsage = {
                     total,
                     systemPrompt: 0,
@@ -3697,6 +3997,9 @@ function _define_property$1(obj, key, value) {
                 this.logger.warn('Could not calculate token usage', {
                     error
                 });
+            } finally{
+                // Always dispose of the counter to prevent resource leaks
+                counter === null || counter === void 0 ? void 0 : counter.dispose();
             }
         }
         return {
@@ -4090,7 +4393,8 @@ function _define_property(obj, key, value) {
             startTime,
             insights: [],
             findings: [],
-            errors: []
+            errors: [],
+            toolFailures: new Map()
         };
         this.logger.info('Starting strategy execution', {
             strategy: strategy.name
@@ -4130,10 +4434,6 @@ function _define_property(obj, key, value) {
                 });
                 const phaseResult = await this.executePhase(conversation, tools, phase, state, strategy);
                 phaseResults.push(phaseResult);
-                // Track iteration for metrics
-                if (this.metricsCollector) {
-                    this.metricsCollector.incrementIteration();
-                }
                 await ((_strategy_onPhaseComplete = strategy.onPhaseComplete) === null || _strategy_onPhaseComplete === void 0 ? void 0 : _strategy_onPhaseComplete.call(strategy, phaseResult, state));
                 // Check if should continue
                 if (strategy.shouldContinue && !strategy.shouldContinue(state)) {
@@ -4228,6 +4528,10 @@ function _define_property(obj, key, value) {
         for(let i = 0; i < phase.maxIterations; i++){
             var _strategy_onIteration;
             state.iteration++;
+            // Track iteration for metrics
+            if (this.metricsCollector) {
+                this.metricsCollector.incrementIteration();
+            }
             this.logger.debug('Iteration', {
                 phase: phase.name,
                 iteration: i + 1
@@ -4253,6 +4557,7 @@ function _define_property(obj, key, value) {
                 conversation.asAssistant(response.content, response.tool_calls);
                 // Execute tools
                 for (const toolCall of response.tool_calls){
+                    var _phase_maxConsecutiveToolFailures;
                     var _strategy_onToolCall;
                     // Check if tool is allowed in this phase
                     if (phase.allowedTools && !phase.allowedTools.includes(toolCall.function.name)) {
@@ -4261,6 +4566,22 @@ function _define_property(obj, key, value) {
                         });
                         continue;
                     }
+                    // Circuit breaker: Check if tool has exceeded failure threshold
+                    const maxFailures = (_phase_maxConsecutiveToolFailures = phase.maxConsecutiveToolFailures) !== null && _phase_maxConsecutiveToolFailures !== void 0 ? _phase_maxConsecutiveToolFailures : 3;
+                    const consecutiveFailures = state.toolFailures.get(toolCall.function.name) || 0;
+                    if (consecutiveFailures >= maxFailures) {
+                        this.logger.warn('Tool circuit breaker triggered', {
+                            tool: toolCall.function.name,
+                            failures: consecutiveFailures
+                        });
+                        conversation.asTool(toolCall.id, {
+                            error: `Tool temporarily disabled due to ${consecutiveFailures} consecutive failures`
+                        }, {
+                            success: false,
+                            circuitBreakerTriggered: true
+                        });
+                        continue;
+                    }
                     // Check tool call hook
                     const toolAction = await ((_strategy_onToolCall = strategy.onToolCall) === null || _strategy_onToolCall === void 0 ? void 0 : _strategy_onToolCall.call(strategy, toolCall, state));
                     if (toolAction === 'skip') {
@@ -4270,7 +4591,18 @@ function _define_property(obj, key, value) {
                     const toolStart = Date.now();
                     try {
                         var _strategy_onToolResult;
-                        const result = await tools.execute(toolCall.function.name, JSON.parse(toolCall.function.arguments));
+                        // Parse tool arguments with error handling
+                        let toolArgs;
+                        try {
+                            toolArgs = JSON.parse(toolCall.function.arguments);
+                        } catch (parseError) {
+                            const error = new Error(`Invalid JSON in tool arguments for ${toolCall.function.name}: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                            if (parseError instanceof Error) {
+                                error.cause = parseError; // Preserve original error
+                            }
+                            throw error;
+                        }
+                        const result = await tools.execute(toolCall.function.name, toolArgs);
                         const toolDuration = Date.now() - toolStart;
                         const toolResult = {
                             callId: toolCall.id,
@@ -4283,6 +4615,8 @@ function _define_property(obj, key, value) {
                             success: true
                         });
                         state.toolCallsExecuted++;
+                        // Reset failure counter on success
+                        state.toolFailures.set(toolCall.function.name, 0);
                         // Record metrics
                         if (this.metricsCollector) {
                             this.metricsCollector.recordToolCall(toolCall.function.name, state.iteration, toolDuration, true);
@@ -4309,6 +4643,9 @@ function _define_property(obj, key, value) {
                             errorName: error.name
                         });
                         state.errors.push(error);
+                        // Increment failure counter for circuit breaker
+                        const failures = (state.toolFailures.get(toolCall.function.name) || 0) + 1;
+                        state.toolFailures.set(toolCall.function.name, failures);
                         // Record metrics
                         if (this.metricsCollector) {
                             this.metricsCollector.recordToolCall(toolCall.function.name, state.iteration, toolDuration, false, error.message);
@@ -4786,7 +5123,7 @@ const cook = async (config)=>{
     if (finalConfig.tools) {
         const tools = Array.isArray(finalConfig.tools) ? finalConfig.tools : finalConfig.tools.getAll();
         // Filter by categories if specified
-        const filteredTools = finalConfig.toolCategories ? tools.filter((tool)=>finalConfig.toolCategories.includes(tool.category || '')) : tools;
+        const filteredTools = finalConfig.toolCategories ? tools.filter((tool)=>tool.category && finalConfig.toolCategories.includes(tool.category)) : tools;
         if (filteredTools.length > 0 && finalConfig.toolGuidance) {
             const guidance = generateToolGuidance(filteredTools, finalConfig.toolGuidance);
             const toolSection = await parser$1.parse(guidance, {
@@ -4950,12 +5287,12 @@ const recipe = (basePath)=>{
             }
             return undefined;
         },
-        executeWith: async (llm, strategy, tokenBudget)=>{
+        executeWith: async (llm, strategy, model = 'gpt-4o', tokenBudget)=>{
             const prompt = await cook(config);
             const conversation = ConversationBuilder.create({
-                model: 'gpt-4o'
+                model
             }, config.logger);
-            conversation.fromPrompt(prompt, 'gpt-4o');
+            conversation.fromPrompt(prompt, model);
             if (tokenBudget) {
                 conversation.withTokenBudget(tokenBudget);
             }
@@ -4992,6 +5329,7 @@ exports.Loader = loader;
 exports.MessageBuilder = MessageBuilder;
 exports.MessageTemplates = MessageTemplates;
 exports.MetricsCollector = MetricsCollector;
+exports.ModelRegistry = ModelRegistry;
 exports.Override = override;
 exports.Parser = parser;
 exports.Recipes = recipes;
@@ -5001,6 +5339,7 @@ exports.TokenBudgetManager = TokenBudgetManager;
 exports.TokenCounter = TokenCounter;
 exports.ToolRegistry = ToolRegistry;
 exports.clearTemplates = clearTemplates;
+exports.configureModel = configureModel;
 exports.cook = cook;
 exports.createContent = create$b;
 exports.createContext = create$a;
@@ -5011,7 +5350,13 @@ exports.createSection = create$8;
 exports.createTrait = create$7;
 exports.createWeighted = create$c;
 exports.generateToolGuidance = generateToolGuidance;
+exports.getEncoding = getEncoding;
+exports.getModelFamily = getModelFamily;
+exports.getModelRegistry = getModelRegistry;
+exports.getPersonaRole = getPersonaRole$1;
 exports.getTemplates = getTemplates;
 exports.recipe = recipe;
 exports.registerTemplates = registerTemplates;
+exports.resetModelRegistry = resetModelRegistry;
+exports.supportsToolCalls = supportsToolCalls;
 //# sourceMappingURL=riotprompt.cjs.map