@riotprompt/riotprompt 0.0.12 → 0.0.13

package/dist/riotprompt.cjs

@@ -7,8 +7,12 @@ const fs = require('fs/promises');
 const path = require('path');
 const crypto = require('crypto');
 const tiktoken = require('tiktoken');
+const OpenAI = require('openai');
+const Anthropic = require('@anthropic-ai/sdk');
+const generativeAi = require('@google/generative-ai');
 const fs$1 = require('fs');
 const glob = require('glob');
+const fastXmlParser = require('fast-xml-parser');
 
 function _interopNamespaceDefault(e) {
     const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
@@ -305,7 +309,7 @@ const wrapLogger = (toWrap, name)=>{
     };
 };
 
-function _define_property$8(obj, key, value) {
+function _define_property$9(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -324,23 +328,14 @@ function _define_property$8(obj, key, value) {
     /**
      * Register default model configurations
      */ registerDefaults() {
-        // GPT-4 family (uses 'system' role)
+        // Default fallback (Registered first so it ends up last with unshift)
         this.register({
-            pattern: /^gpt-4/i,
+            pattern: /.*/,
             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'
+            family: 'unknown',
+            description: 'Default fallback configuration'
         });
         // Claude family (uses 'system' role)
         this.register({
@@ -351,27 +346,37 @@ function _define_property$8(obj, key, value) {
             family: 'claude',
             description: 'Claude family models'
         });
-        // Default fallback
+        // O-series models (uses 'developer' role)
         this.register({
-            pattern: /.*/,
+            pattern: /^o\d+/i,
+            personaRole: 'developer',
+            encoding: 'gpt-4o',
+            supportsToolCalls: true,
+            family: 'o-series',
+            description: 'O-series reasoning models'
+        });
+        // GPT-4 family (uses 'system' role)
+        this.register({
+            pattern: /^gpt-4/i,
             personaRole: 'system',
             encoding: 'gpt-4o',
             supportsToolCalls: true,
-            family: 'unknown',
-            description: 'Default fallback configuration'
+            family: 'gpt-4',
+            description: 'GPT-4 family models'
         });
         this.logger.debug('Registered default model configurations');
     }
     /**
      * Register a model configuration
      * Configs are checked in registration order (first match wins)
+     * New configs are added to the beginning of the list (high priority)
      */ 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.configs.unshift(config);
         this.cache.clear(); // Clear cache when new config is added
         this.logger.debug('Registered model config', {
             family: config.family,
@@ -443,9 +448,9 @@ function _define_property$8(obj, key, value) {
         ];
     }
     constructor(logger){
-        _define_property$8(this, "configs", void 0);
-        _define_property$8(this, "cache", void 0);
-        _define_property$8(this, "logger", void 0);
+        _define_property$9(this, "configs", void 0);
+        _define_property$9(this, "cache", void 0);
+        _define_property$9(this, "logger", void 0);
         this.configs = [];
         this.cache = new Map();
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ModelRegistry');
@@ -1593,7 +1598,7 @@ const builder = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     create
 }, Symbol.toStringTag, { value: 'Module' }));
 
-function _define_property$7(obj, key, value) {
+function _define_property$8(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -1822,16 +1827,16 @@ function _define_property$7(obj, key, value) {
         return content.replace(/\s+/g, ' ').trim().toLowerCase();
     }
     constructor(logger){
-        _define_property$7(this, "items", void 0);
-        _define_property$7(this, "hashes", void 0);
-        _define_property$7(this, "logger", void 0);
+        _define_property$8(this, "items", void 0);
+        _define_property$8(this, "hashes", void 0);
+        _define_property$8(this, "logger", void 0);
         this.items = new Map();
         this.hashes = new Set();
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ContextManager');
     }
 }
 
-function _define_property$6(obj, key, value) {
+function _define_property$7(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -2004,7 +2009,12 @@ function _define_property$6(obj, key, value) {
         }
         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';
+        let ext = '.json';
+        if (this.config.format === 'markdown') {
+            ext = '.md';
+        } else if (this.config.format === 'jsonl') {
+            ext = '.jsonl';
+        }
         const fullPath = path.join(this.config.outputPath, filename + ext);
         // Ensure directory exists
         await fs.mkdir(path.dirname(fullPath), {
@@ -2096,16 +2106,16 @@ function _define_property$6(obj, key, value) {
         return redacted;
     }
     constructor(config, logger){
-        _define_property$6(this, "config", void 0);
-        _define_property$6(this, "conversationId", void 0);
-        _define_property$6(this, "metadata", void 0);
-        _define_property$6(this, "messages", void 0);
-        _define_property$6(this, "toolCalls", void 0);
-        _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());
+        _define_property$7(this, "config", void 0);
+        _define_property$7(this, "conversationId", void 0);
+        _define_property$7(this, "metadata", void 0);
+        _define_property$7(this, "messages", void 0);
+        _define_property$7(this, "toolCalls", void 0);
+        _define_property$7(this, "startTime", void 0);
+        _define_property$7(this, "logger", void 0);
+        _define_property$7(this, "messageIndex", void 0);
+        _define_property$7(this, "cachedOutputPath", void 0);
+        _define_property$7(this, "writeQueue", Promise.resolve());
         this.config = {
             outputPath: 'logs/conversations',
             format: 'json',
@@ -2309,14 +2319,14 @@ function _define_property$6(obj, key, value) {
         await fs.writeFile(outputPath, markdown, 'utf-8');
     }
     constructor(conversation, logger){
-        _define_property$6(this, "conversation", void 0);
-        _define_property$6(this, "logger", void 0);
+        _define_property$7(this, "conversation", void 0);
+        _define_property$7(this, "logger", void 0);
         this.conversation = conversation;
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ConversationReplayer');
     }
 }
 
-function _define_property$5(obj, key, value) {
+function _define_property$6(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -2499,13 +2509,13 @@ function _define_property$5(obj, key, value) {
         return message;
     }
     constructor(role, logger){
-        _define_property$5(this, "semanticRole", void 0);
-        _define_property$5(this, "contentParts", void 0);
-        _define_property$5(this, "metadata", void 0);
-        _define_property$5(this, "formatter", void 0);
-        _define_property$5(this, "toolCallId", void 0);
-        _define_property$5(this, "toolCalls", void 0);
-        _define_property$5(this, "logger", void 0);
+        _define_property$6(this, "semanticRole", void 0);
+        _define_property$6(this, "contentParts", void 0);
+        _define_property$6(this, "metadata", void 0);
+        _define_property$6(this, "formatter", void 0);
+        _define_property$6(this, "toolCallId", void 0);
+        _define_property$6(this, "toolCalls", void 0);
+        _define_property$6(this, "logger", void 0);
         this.semanticRole = role;
         this.contentParts = [];
         this.metadata = {};
@@ -2566,7 +2576,7 @@ function _define_property$5(obj, key, value) {
     }
 };
 
-function _define_property$4(obj, key, value) {
+function _define_property$5(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -2682,9 +2692,9 @@ function _define_property$4(obj, key, value) {
         this.encoder.free();
     }
     constructor(model, logger){
-        _define_property$4(this, "encoder", void 0);
-        _define_property$4(this, "model", void 0);
-        _define_property$4(this, "logger", void 0);
+        _define_property$5(this, "encoder", void 0);
+        _define_property$5(this, "model", void 0);
+        _define_property$5(this, "logger", void 0);
         this.model = model;
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'TokenCounter');
         // Map RiotPrompt models to Tiktoken models
@@ -2940,9 +2950,9 @@ function _define_property$4(obj, key, value) {
         this.counter.dispose();
     }
     constructor(config, model, logger){
-        _define_property$4(this, "config", void 0);
-        _define_property$4(this, "counter", void 0);
-        _define_property$4(this, "logger", void 0);
+        _define_property$5(this, "config", void 0);
+        _define_property$5(this, "counter", void 0);
+        _define_property$5(this, "logger", void 0);
         this.config = {
             warningThreshold: 0.8,
             preserveRecent: 3,
@@ -2961,7 +2971,7 @@ function _define_property$4(obj, key, value) {
     }
 }
 
-function _define_property$3(obj, key, value) {
+function _define_property$4(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -3575,11 +3585,11 @@ const ConversationBuilderConfigSchema = zod.z.object({
         this.state.metadata.lastModified = new Date();
     }
     constructor(config, logger){
-        _define_property$3(this, "state", void 0);
-        _define_property$3(this, "config", void 0);
-        _define_property$3(this, "logger", void 0);
-        _define_property$3(this, "budgetManager", void 0);
-        _define_property$3(this, "conversationLogger", void 0);
+        _define_property$4(this, "state", void 0);
+        _define_property$4(this, "config", void 0);
+        _define_property$4(this, "logger", void 0);
+        _define_property$4(this, "budgetManager", void 0);
+        _define_property$4(this, "conversationLogger", void 0);
         this.config = ConversationBuilderConfigSchema.parse(config);
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ConversationBuilder');
         this.state = {
@@ -3600,7 +3610,7 @@ const ConversationBuilderConfigSchema = zod.z.object({
     }
 }
 
-function _define_property$2(obj, key, value) {
+function _define_property$3(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -3907,10 +3917,10 @@ const ToolSchema = zod.z.object({
         });
     }
     constructor(context = {}, logger){
-        _define_property$2(this, "tools", void 0);
-        _define_property$2(this, "context", void 0);
-        _define_property$2(this, "logger", void 0);
-        _define_property$2(this, "usageStats", void 0);
+        _define_property$3(this, "tools", void 0);
+        _define_property$3(this, "context", void 0);
+        _define_property$3(this, "logger", void 0);
+        _define_property$3(this, "usageStats", void 0);
         this.tools = new Map();
         this.context = context;
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ToolRegistry');
@@ -3919,7 +3929,7 @@ const ToolSchema = zod.z.object({
     }
 }
 
-function _define_property$1(obj, key, value) {
+function _define_property$2(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -4050,10 +4060,10 @@ function _define_property$1(obj, key, value) {
         return stats;
     }
     constructor(logger){
-        _define_property$1(this, "startTime", void 0);
-        _define_property$1(this, "toolMetrics", void 0);
-        _define_property$1(this, "iterationCount", void 0);
-        _define_property$1(this, "logger", void 0);
+        _define_property$2(this, "startTime", void 0);
+        _define_property$2(this, "toolMetrics", void 0);
+        _define_property$2(this, "iterationCount", void 0);
+        _define_property$2(this, "logger", void 0);
         this.startTime = new Date();
         this.toolMetrics = [];
         this.iterationCount = 0;
@@ -4328,12 +4338,12 @@ function _define_property$1(obj, key, value) {
         return markdown;
     }
     constructor(logger){
-        _define_property$1(this, "logger", void 0);
+        _define_property$2(this, "logger", void 0);
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'ReflectionReportGenerator');
     }
 }
 
-function _define_property(obj, key, value) {
+function _define_property$1(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -4685,10 +4695,10 @@ function _define_property(obj, key, value) {
         };
     }
     constructor(llm, logger){
-        _define_property(this, "llm", void 0);
-        _define_property(this, "logger", void 0);
-        _define_property(this, "metricsCollector", void 0);
-        _define_property(this, "reflectionConfig", void 0);
+        _define_property$1(this, "llm", void 0);
+        _define_property$1(this, "logger", void 0);
+        _define_property$1(this, "metricsCollector", void 0);
+        _define_property$1(this, "reflectionConfig", void 0);
         this.llm = llm;
         this.logger = wrapLogger(logger || DEFAULT_LOGGER, 'StrategyExecutor');
     }
@@ -5317,12 +5327,535 @@ const recipes = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     registerTemplates
 }, Symbol.toStringTag, { value: 'Module' }));
 
+const toJSON = (prompt)=>{
+    return JSON.stringify(prompt, null, 2);
+};
+const escapeXML = (str)=>{
+    return str.replace(/[<>&'"]/g, (c)=>{
+        switch(c){
+            case '<':
+                return '&lt;';
+            case '>':
+                return '&gt;';
+            case '&':
+                return '&amp;';
+            case '\'':
+                return '&apos;';
+            case '"':
+                return '&quot;';
+            default:
+                return c;
+        }
+    });
+};
+const itemToXML = (item)=>{
+    if (typeof item === 'string') {
+        return `<item>${escapeXML(item)}</item>`;
+    }
+    // Check if it's a section
+    if (item && typeof item === 'object' && 'items' in item) {
+        return sectionToXML(item);
+    }
+    // Check if it's a weighted item
+    if (item && typeof item === 'object' && 'text' in item) {
+        const weightAttr = item.weight !== undefined && item.weight !== null ? ` weight="${item.weight}"` : '';
+        return `<item${weightAttr}>${escapeXML(item.text)}</item>`;
+    }
+    return '';
+};
+const sectionToXML = (section, tagName = 'section')=>{
+    const titleAttr = section.title ? ` title="${escapeXML(section.title)}"` : '';
+    const weightAttr = section.weight ? ` weight="${section.weight}"` : '';
+    let xml = `<${tagName}${titleAttr}${weightAttr}>`;
+    if (section.items && Array.isArray(section.items)) {
+        xml += section.items.map((item)=>itemToXML(item)).join('');
+    }
+    xml += `</${tagName}>`;
+    return xml;
+};
+const toXML = (prompt)=>{
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<prompt>';
+    if (prompt.persona) {
+        xml += sectionToXML(prompt.persona, 'persona');
+    }
+    if (prompt.instructions) {
+        xml += sectionToXML(prompt.instructions, 'instructions');
+    }
+    if (prompt.contents) {
+        xml += sectionToXML(prompt.contents, 'contents');
+    }
+    if (prompt.contexts) {
+        xml += sectionToXML(prompt.contexts, 'contexts');
+    }
+    xml += '</prompt>';
+    return xml;
+};
+// ============================================================================
+// DESERIALIZATION
+// ============================================================================
+// --- JSON Parsing ---
+const parseSectionFromJSON = (jsonSection)=>{
+    if (!jsonSection || !jsonSection.items) {
+        throw new Error("Invalid section structure");
+    }
+    const section = create$8({
+        title: jsonSection.title,
+        weight: jsonSection.weight
+    });
+    for (const item of jsonSection.items){
+        if (typeof item === 'object' && 'items' in item) {
+            // It's a nested section
+            section.add(parseSectionFromJSON(item));
+        } else if (typeof item === 'object' && 'text' in item) {
+            section.add({
+                text: item.text,
+                weight: item.weight
+            });
+        } else if (typeof item === 'string') {
+            section.add(item);
+        }
+    }
+    return section;
+};
+const fromJSON = (jsonString)=>{
+    const json = JSON.parse(jsonString);
+    // We treat the root json object as matching Prompt interface
+    // But we need to convert plain objects back to Section instances with methods
+    const persona = json.persona ? parseSectionFromJSON(json.persona) : undefined;
+    const instructions = json.instructions ? parseSectionFromJSON(json.instructions) : create$8({
+        title: 'Instructions'
+    });
+    const contents = json.contents ? parseSectionFromJSON(json.contents) : undefined;
+    const contexts = json.contexts ? parseSectionFromJSON(json.contexts) : undefined;
+    return create$6({
+        persona,
+        instructions,
+        contents,
+        contexts
+    });
+};
+// --- XML Parsing ---
+const parseNodeToSection = (node)=>{
+    // Node structure with preserveOrder: true
+    // It seems attributes can be a sibling property ":@" OR inside the children array depending on version/config/content.
+    // Children are in the array value of the key "section", "persona", etc.
+    const children = node.section || node.persona || node.instructions || node.contents || node.contexts || [];
+    let attributes = node[":@"] || {};
+    // Fallback: check if attributes are inside the children array (as seen in some tests/mocks)
+    if (!node[":@"] && Array.isArray(children)) {
+        for (const child of children){
+            if (child[":@"]) {
+                attributes = child[":@"];
+                break;
+            }
+        }
+    }
+    const title = attributes["@_title"];
+    const weight = attributes["@_weight"] ? Number(attributes["@_weight"]) : undefined;
+    const section = create$8({
+        title,
+        weight
+    });
+    if (Array.isArray(children)) {
+        for (const child of children){
+            const key = Object.keys(child)[0]; // "item" or "section" or ":@"
+            // console.log(`Processing child key: ${key}`);
+            if (key === ":@") continue; // Already handled or just attributes
+            if (key === "item") {
+                // Item structure: [ { "#text": "Value" }, { ":@": ... } ]
+                const itemContent = child.item;
+                let text = "";
+                let itemWeight = undefined;
+                for (const part of itemContent){
+                    const keys = Object.keys(part);
+                    // console.log('Processing item part keys:', keys);
+                    if (keys.includes("#text")) {
+                        text = part["#text"];
+                    } else if (keys.includes(":@")) {
+                        const attrs = part[":@"];
+                        // console.log('Found attributes:', attrs);
+                        // Check both with and without prefix just in case
+                        const w = attrs["@_weight"] || attrs["weight"];
+                        if (w !== undefined) itemWeight = Number(w);
+                    } else {
+                        // Fallback for cases where attributes might be directly on the part (unexpected but possible)
+                        const w = part["@_weight"] || part["weight"];
+                        if (w !== undefined) itemWeight = Number(w);
+                    }
+                }
+                // console.log(`Adding item: ${text}`);
+                section.add({
+                    text,
+                    weight: itemWeight
+                });
+            } else if (key === "section") {
+                section.add(parseNodeToSection(child));
+            }
+        }
+    }
+    return section;
+};
+const fromXML = (xmlString)=>{
+    const parser = new fastXmlParser.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_",
+        preserveOrder: true,
+        trimValues: true
+    });
+    const parsed = parser.parse(xmlString);
+    // parsed is [ { "?xml": ... }, { "prompt": [ ... ] } ]
+    let promptNode = null;
+    for (const node of parsed){
+        if (node.prompt) {
+            promptNode = node.prompt;
+            break;
+        }
+    }
+    if (!promptNode) throw new Error("Invalid XML: missing <prompt> root");
+    let persona;
+    let instructions = create$8({
+        title: "Instructions"
+    });
+    let contents;
+    let contexts;
+    for (const child of promptNode){
+        if (child.persona) {
+            persona = parseNodeToSection(child);
+            persona.title = "Persona"; // Force title for standard sections?
+        } else if (child.instructions) {
+            instructions = parseNodeToSection(child);
+            instructions.title = "Instructions";
+        } else if (child.contents) {
+            contents = parseNodeToSection(child);
+            contents.title = "Contents";
+        } else if (child.contexts) {
+            contexts = parseNodeToSection(child);
+            contexts.title = "Contexts";
+        }
+    }
+    return create$6({
+        persona,
+        instructions,
+        contents,
+        contexts
+    });
+};
+
+const serializer = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    fromJSON,
+    fromXML,
+    toJSON,
+    toXML
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const saveToDirectory = async (prompt, basePath)=>{
+    // Ensure base directory exists
+    await fs__namespace.mkdir(basePath, {
+        recursive: true
+    });
+    // 1. Save Persona
+    if (prompt.persona) {
+        await saveSection(prompt.persona, path__namespace.join(basePath, 'persona'));
+    }
+    // 2. Save Instructions
+    if (prompt.instructions) {
+        await saveSection(prompt.instructions, path__namespace.join(basePath, 'instructions'));
+    }
+    // 3. Save Context
+    if (prompt.contexts) {
+        await saveSection(prompt.contexts, path__namespace.join(basePath, 'context'));
+    }
+    // 4. Save Content (if any)
+    if (prompt.contents) {
+        await saveSection(prompt.contents, path__namespace.join(basePath, 'content'));
+    }
+};
+const saveSection = async (section, targetPath)=>{
+    // If section has subsections, create a directory and recurse
+    // If section only has items, check if we can save as single file (e.g. name of section + .md)
+    // Simplification: We will use a mixed approach.
+    // If the section is "flat" (only items), we can write it to a file.
+    // If the section is "nested" (has subsections), we create a directory.
+    // However, to be consistent with Loader logic:
+    // Loader reads files in a directory as subsections.
+    // So if we have a section "Instructions", and we save it as a directory "instructions":
+    // Its items become content of files?
+    // Strategy:
+    // 1. Create directory `targetPath`.
+    // 2. If the section has items (text), verify if they have titles (subsections).
+    // 3. For each item:
+    //    - If it's a string/Instruction/Content/Context (leaf):
+    //      - If the parent section is the ROOT (e.g. 'persona'), and it's just text, maybe we prefer `persona.md`.
+    //    - If it's a subsection:
+    //      - Recurse into subdirectory.
+    // Let's refine based on typical usage:
+    // - Persona: usually one big text. -> `persona.md`
+    // - Instructions: usually one big text or list of files. -> `instructions.md` or `instructions/part1.md`
+    // - Context: usually list of files. -> `context/data.json`, `context/info.md`
+    // We need to differentiate based on the targetPath provided by caller.
+    // If targetPath ends in "persona" (directory name), we can choose to write `targetPath.md` instead if it's flat.
+    // But `saveToDirectory` created `basePath/persona` (directory path string).
+    // Let's check complexity:
+    const hasSubsections = section.items.some((item)=>typeof item === 'object' && 'items' in item);
+    if (!hasSubsections) {
+        // Flat section. 
+        // If it has multiple items, we can join them? Or write as numbered files?
+        // Usually, a flat section implies content for a single file.
+        // We prefer to write to `targetPath.md`.
+        const content = section.items.map((item)=>{
+            if (typeof item === 'string') return item;
+            return item.text;
+        }).join('\n\n');
+        // Check if we should write to .md file instead of directory
+        // targetPath is e.g. ".../persona". We want ".../persona.md".
+        await fs__namespace.writeFile(`${targetPath}.md`, content);
+        return;
+    }
+    // Nested section
+    await fs__namespace.mkdir(targetPath, {
+        recursive: true
+    });
+    for(let i = 0; i < section.items.length; i++){
+        const item = section.items[i];
+        if (typeof item === 'object' && 'items' in item) {
+            // Subsection
+            // Use title as filename/dirname
+            const subTitle = item.title || `part-${i + 1}`;
+            const subPath = path__namespace.join(targetPath, subTitle);
+            await saveSection(item, subPath);
+        } else {
+            // Leaf item mixed with subsections.
+            // Write to a file. 
+            // If it's just text, we need a filename.
+            const fileName = `item-${i + 1}.md`;
+            const content = typeof item === 'string' ? item : item.text;
+            await fs__namespace.writeFile(path__namespace.join(targetPath, fileName), content);
+        }
+    }
+};
+
+const writer = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    saveToDirectory
+}, Symbol.toStringTag, { value: 'Module' }));
+
+class OpenAIProvider {
+    async execute(request, options = {}) {
+        const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey) throw new Error('OpenAI API key is required');
+        const client = new OpenAI({
+            apiKey
+        });
+        const model = options.model || request.model || 'gpt-4';
+        // Convert RiotPrompt messages to OpenAI messages
+        const messages = request.messages.map((msg)=>{
+            const role = msg.role === 'developer' ? 'system' : msg.role; // OpenAI uses system, not developer usually (except o1)
+            // But wait, o1 uses developer. Let's respect what formatter gave us if valid.
+            // OpenAI Node SDK types expect specific roles.
+            // RiotPrompt roles: "user" | "assistant" | "system" | "developer"
+            // OpenAI roles: "system" | "user" | "assistant" | "tool" | "function" | "developer" (recent versions)
+            // We'll cast to any to avoid strict type issues with older/newer SDK versions mismatch
+            return {
+                role: role,
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+                name: msg.name
+            };
+        });
+        const response = await client.chat.completions.create({
+            model: model,
+            messages: messages,
+            temperature: options.temperature,
+            max_tokens: options.maxTokens
+        });
+        const choice = response.choices[0];
+        return {
+            content: choice.message.content || '',
+            model: response.model,
+            usage: response.usage ? {
+                inputTokens: response.usage.prompt_tokens,
+                outputTokens: response.usage.completion_tokens
+            } : undefined
+        };
+    }
+}
+
+class AnthropicProvider {
+    async execute(request, options = {}) {
+        const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) throw new Error('Anthropic API key is required');
+        const client = new Anthropic({
+            apiKey
+        });
+        const model = options.model || request.model || 'claude-3-opus-20240229';
+        // Anthropic separates system prompt from messages
+        let systemPrompt = '';
+        const messages = [];
+        for (const msg of request.messages){
+            if (msg.role === 'system' || msg.role === 'developer') {
+                systemPrompt += (typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)) + '\n\n';
+            } else {
+                messages.push({
+                    role: msg.role,
+                    content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+                });
+            }
+        }
+        const response = await client.messages.create({
+            model: model,
+            system: systemPrompt.trim() || undefined,
+            messages: messages,
+            max_tokens: options.maxTokens || 4096,
+            temperature: options.temperature
+        });
+        // Handle ContentBlock
+        const contentBlock = response.content[0];
+        const text = contentBlock.type === 'text' ? contentBlock.text : '';
+        return {
+            content: text,
+            model: response.model,
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens
+            }
+        };
+    }
+}
+
+class GeminiProvider {
+    async execute(request, options = {}) {
+        const apiKey = options.apiKey || process.env.GEMINI_API_KEY; // or GOOGLE_API_KEY
+        if (!apiKey) throw new Error('Gemini API key is required');
+        const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
+        const modelName = options.model || request.model || 'gemini-1.5-pro';
+        // Gemini format: system instruction is separate, history is separate from last message
+        // generateContent accepts a string or parts.
+        // We need to construct the prompt.
+        // Simple approach: Concat system instructions + chat history
+        let systemInstruction = '';
+        // Extract system prompt
+        for (const msg of request.messages){
+            if (msg.role === 'system' || msg.role === 'developer') {
+                systemInstruction += (typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)) + '\n\n';
+            }
+        }
+        // Configure model with system instruction if available (newer Gemini versions support this)
+        // Or just prepend to first user message.
+        // Let's try to prepend for compatibility if needed, but 'systemInstruction' param exists in getGenerativeModel config.
+        const configuredModel = genAI.getGenerativeModel({
+            model: modelName,
+            systemInstruction: systemInstruction ? systemInstruction.trim() : undefined
+        });
+        // Build history/messages
+        // Gemini `generateContent` takes the *last* user message.
+        // `startChat` takes history.
+        const chatHistory = [];
+        let lastUserMessage = '';
+        for (const msg of request.messages){
+            if (msg.role === 'system' || msg.role === 'developer') continue;
+            const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+            if (msg.role === 'user') {
+                lastUserMessage = content; // Assuming strictly alternating or we just want the prompt?
+            // If there are multiple messages, we should build a chat.
+            }
+            chatHistory.push({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [
+                    {
+                        text: content
+                    }
+                ]
+            });
+        }
+        // If we are just running a prompt (single turn), we can use generateContent with the full text.
+        // But let's support multi-turn by using startChat if history > 1.
+        // If it's a typical "Prompt" execution, it's usually System + 1 User message.
+        let result;
+        if (chatHistory.length > 1) {
+            // Remove last message from history to send it
+            const lastMsg = chatHistory.pop();
+            const chat = configuredModel.startChat({
+                history: chatHistory
+            });
+            result = await chat.sendMessage((lastMsg === null || lastMsg === void 0 ? void 0 : lastMsg.parts[0].text) || '');
+        } else {
+            // Just one message (or none?)
+            result = await configuredModel.generateContent(lastUserMessage || ' ');
+        }
+        const response = await result.response;
+        const text = response.text();
+        return {
+            content: text,
+            model: modelName,
+            // Gemini usage metadata usageMetadata
+            usage: response.usageMetadata ? {
+                inputTokens: response.usageMetadata.promptTokenCount,
+                outputTokens: response.usageMetadata.candidatesTokenCount
+            } : undefined
+        };
+    }
+}
+
+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;
+}
+class ExecutionManager {
+    getProvider(model) {
+        if (!model) {
+            // Default to OpenAI if model is undefined
+            return this.providers.get('openai');
+        }
+        if (model.startsWith('gpt') || model.startsWith('o1')) {
+            return this.providers.get('openai');
+        } else if (model.startsWith('claude')) {
+            return this.providers.get('anthropic');
+        } else if (model.startsWith('gemini')) {
+            return this.providers.get('gemini');
+        }
+        // Fallback or default?
+        return this.providers.get('openai');
+    }
+    async execute(request, options = {}) {
+        const model = options.model || request.model;
+        const provider = this.getProvider(model);
+        return provider.execute(request, options);
+    }
+    constructor(){
+        _define_property(this, "providers", void 0);
+        this.providers = new Map();
+        this.providers.set('openai', new OpenAIProvider());
+        this.providers.set('anthropic', new AnthropicProvider());
+        this.providers.set('gemini', new GeminiProvider());
+    }
+}
+const execute = async (request, options = {})=>{
+    const manager = new ExecutionManager();
+    return manager.execute(request, options);
+};
+
+const index = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    ExecutionManager,
+    execute
+}, Symbol.toStringTag, { value: 'Module' }));
+
 exports.Builder = builder;
 exports.Chat = chat;
 exports.ContextManager = ContextManager;
 exports.ConversationBuilder = ConversationBuilder;
 exports.ConversationLogger = ConversationLogger;
 exports.ConversationReplayer = ConversationReplayer;
+exports.Execution = index;
 exports.Formatter = formatter;
 exports.IterationStrategyFactory = IterationStrategyFactory;
 exports.Loader = loader;
@@ -5334,10 +5867,12 @@ exports.Override = override;
 exports.Parser = parser;
 exports.Recipes = recipes;
 exports.ReflectionReportGenerator = ReflectionReportGenerator;
+exports.Serializer = serializer;
 exports.StrategyExecutor = StrategyExecutor;
 exports.TokenBudgetManager = TokenBudgetManager;
 exports.TokenCounter = TokenCounter;
 exports.ToolRegistry = ToolRegistry;
+exports.Writer = writer;
 exports.clearTemplates = clearTemplates;
 exports.configureModel = configureModel;
 exports.cook = cook;