@riotprompt/riotprompt 0.0.12 → 0.0.14

package/dist/riotprompt.cjs

@@ -5,10 +5,15 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const zod = require('zod');
 const fs = require('fs/promises');
 const path = require('path');
+const zodToJsonSchema = require('zod-to-json-schema');
 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' } });
@@ -232,12 +237,21 @@ const create$7 = (text, options = {})=>{
     return create$c(text, weightedOptions);
 };
 
-const create$6 = ({ persona, instructions, contents, contexts })=>{
+const create$6 = ({ persona, instructions, contents, contexts, constraints, tone, examples, reasoning, responseFormat, recap, safeguards, schema, validator })=>{
     return {
         persona,
         instructions,
         contents,
-        contexts
+        contexts,
+        constraints,
+        tone,
+        examples,
+        reasoning,
+        responseFormat,
+        recap,
+        safeguards,
+        schema,
+        validator
     };
 };
 
@@ -305,7 +319,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 +338,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 +356,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 +458,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');
@@ -514,6 +529,8 @@ const createRequest = (model)=>{
     return {
         model,
         messages,
+        responseFormat: undefined,
+        validator: undefined,
         addMessage: (message)=>{
             messages.push(message);
         }
@@ -666,24 +683,52 @@ const create$5 = (formatterOptions)=>{
     const formatPrompt = (model, prompt)=>{
         logger.silly('Formatting prompt');
         const chatRequest = createRequest(model);
-        if (prompt.persona) {
-            [
-                prompt.persona
-            ].forEach((persona)=>{
-                chatRequest.addMessage(formatPersona(model, persona));
+        // --- System/Role Message Construction ---
+        // Collect sections that belong in the system/developer prompt (Persona, Tone, Constraints, etc.)
+        const systemSections = [];
+        if (prompt.persona) systemSections.push(prompt.persona);
+        if (prompt.tone) systemSections.push(prompt.tone);
+        if (prompt.constraints) systemSections.push(prompt.constraints);
+        if (prompt.safeguards) systemSections.push(prompt.safeguards);
+        if (prompt.responseFormat) systemSections.push(prompt.responseFormat);
+        if (systemSections.length > 0) {
+            // Combine all system sections into one system message content
+            const systemContent = systemSections.map((section)=>formatSection(section)).join('\n\n');
+            chatRequest.addMessage({
+                role: getPersonaRole(model),
+                content: systemContent
+            });
+        }
+        // --- User/Task Message Construction ---
+        // Logical flow: Context -> Examples -> Instructions -> Content -> Reasoning -> Recap
+        // This structure guides the model through the context and examples before presenting the core task
+        const userSections = [
+            prompt.contexts,
+            prompt.examples,
+            prompt.instructions,
+            prompt.contents,
+            prompt.reasoning,
+            prompt.recap
+        ];
+        let formattedUserContent = "";
+        for (const section of userSections){
+            if (section) {
+                formattedUserContent += formatSection(section) + '\n\n';
+            }
+        }
+        // Ensure we always have a user message, or if we have content to send
+        if (formattedUserContent.trim().length > 0 || systemSections.length === 0) {
+            chatRequest.addMessage({
+                role: "user",
+                content: formattedUserContent.trim() || " "
             });
         }
-        let formattedAreas = formatSection(prompt.instructions) + '\n\n';
-        if (prompt.contents) {
-            formattedAreas += formatSection(prompt.contents) + '\n\n';
+        if (prompt.schema) {
+            chatRequest.responseFormat = prompt.schema;
         }
-        if (prompt.contexts) {
-            formattedAreas += formatSection(prompt.contexts) + '\n\n';
+        if (prompt.validator) {
+            chatRequest.validator = prompt.validator;
         }
-        chatRequest.addMessage({
-            role: "user",
-            content: formattedAreas
-        });
         return chatRequest;
     };
     return {
@@ -1593,7 +1638,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 +1867,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 +2049,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 +2146,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 +2359,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 +2549,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 +2616,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 +2732,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 +2990,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 +3011,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 +3625,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 +3650,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 +3957,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 +3969,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 +4100,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 +4378,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 +4735,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');
     }
@@ -4881,6 +4931,15 @@ const RecipeConfigSchema = zod.z.object({
     instructions: zod.z.array(ContentItemSchema).optional().default([]),
     content: zod.z.array(ContentItemSchema).optional().default([]),
     context: zod.z.array(ContentItemSchema).optional().default([]),
+    // Advanced prompting sections
+    constraints: zod.z.array(ContentItemSchema).optional().default([]),
+    tone: zod.z.array(ContentItemSchema).optional().default([]),
+    examples: zod.z.array(ContentItemSchema).optional().default([]),
+    reasoning: zod.z.array(ContentItemSchema).optional().default([]),
+    responseFormat: zod.z.array(ContentItemSchema).optional().default([]),
+    recap: zod.z.array(ContentItemSchema).optional().default([]),
+    safeguards: zod.z.array(ContentItemSchema).optional().default([]),
+    schema: zod.z.any().optional(),
     // Templates and inheritance
     extends: zod.z.string().optional(),
     template: zod.z.string().optional(),
@@ -5046,6 +5105,13 @@ const cook = async (config)=>{
         instructions: [],
         content: [],
         context: [],
+        constraints: [],
+        tone: [],
+        examples: [],
+        reasoning: [],
+        responseFormat: [],
+        recap: [],
+        safeguards: [],
         ...config
     });
     // Handle template inheritance
@@ -5069,7 +5135,36 @@ const cook = async (config)=>{
                 context: [
                     ...template.context || [],
                     ...validatedConfig.context || []
-                ]
+                ],
+                constraints: [
+                    ...template.constraints || [],
+                    ...validatedConfig.constraints || []
+                ],
+                tone: [
+                    ...template.tone || [],
+                    ...validatedConfig.tone || []
+                ],
+                examples: [
+                    ...template.examples || [],
+                    ...validatedConfig.examples || []
+                ],
+                reasoning: [
+                    ...template.reasoning || [],
+                    ...validatedConfig.reasoning || []
+                ],
+                responseFormat: [
+                    ...template.responseFormat || [],
+                    ...validatedConfig.responseFormat || []
+                ],
+                recap: [
+                    ...template.recap || [],
+                    ...validatedConfig.recap || []
+                ],
+                safeguards: [
+                    ...template.safeguards || [],
+                    ...validatedConfig.safeguards || []
+                ],
+                schema: validatedConfig.schema || template.schema
             };
         }
     }
@@ -5101,6 +5196,39 @@ const cook = async (config)=>{
     const contextSection = create$8({
         title: "Context"
     });
+    // Advanced sections
+    const constraintSection = create$8({
+        title: "Constraints"
+    });
+    const toneSection = create$8({
+        title: "Tone"
+    });
+    const exampleSection = create$8({
+        title: "Examples"
+    });
+    const reasoningSection = create$8({
+        title: "Reasoning"
+    });
+    const responseFormatSection = create$8({
+        title: "Response Format"
+    });
+    const recapSection = create$8({
+        title: "Recap"
+    });
+    const safeguardSection = create$8({
+        title: "Safeguards"
+    });
+    // Helper for processing list items
+    const processList = async (items, section, type)=>{
+        for (const item of items){
+            await processContentItem(item, section, type, {
+                basePath: finalConfig.basePath,
+                parser: parser$1,
+                override: override$1,
+                loader: loader$1,
+                parameters: finalConfig.parameters});
+        }
+    };
     // Process persona
     if (finalConfig.persona) {
         await processContentItem(finalConfig.persona, personaSection, 'persona', {
@@ -5110,15 +5238,18 @@ const cook = async (config)=>{
             loader: loader$1,
             parameters: finalConfig.parameters});
     }
-    // Process instructions
-    for (const item of finalConfig.instructions || []){
-        await processContentItem(item, instructionSection, 'instruction', {
-            basePath: finalConfig.basePath,
-            parser: parser$1,
-            override: override$1,
-            loader: loader$1,
-            parameters: finalConfig.parameters});
-    }
+    // Process standard sections
+    await processList(finalConfig.instructions || [], instructionSection, 'instruction');
+    await processList(finalConfig.content || [], contentSection, 'content');
+    await processList(finalConfig.context || [], contextSection, 'context');
+    // Process advanced sections
+    await processList(finalConfig.constraints || [], constraintSection, 'instruction');
+    await processList(finalConfig.tone || [], toneSection, 'instruction');
+    await processList(finalConfig.examples || [], exampleSection, 'content');
+    await processList(finalConfig.reasoning || [], reasoningSection, 'instruction');
+    await processList(finalConfig.responseFormat || [], responseFormatSection, 'instruction');
+    await processList(finalConfig.recap || [], recapSection, 'instruction');
+    await processList(finalConfig.safeguards || [], safeguardSection, 'instruction');
     // Generate tool guidance if tools are provided
     if (finalConfig.tools) {
         const tools = Array.isArray(finalConfig.tools) ? finalConfig.tools : finalConfig.tools.getAll();
@@ -5132,30 +5263,59 @@ const cook = async (config)=>{
             instructionSection.add(toolSection);
         }
     }
-    // Process content
-    for (const item of finalConfig.content || []){
-        await processContentItem(item, contentSection, 'content', {
-            basePath: finalConfig.basePath,
-            parser: parser$1,
-            override: override$1,
-            loader: loader$1,
-            parameters: finalConfig.parameters});
-    }
-    // Process context
-    for (const item of finalConfig.context || []){
-        await processContentItem(item, contextSection, 'context', {
-            basePath: finalConfig.basePath,
-            parser: parser$1,
-            override: override$1,
-            loader: loader$1,
-            parameters: finalConfig.parameters});
+    // Process schema
+    let schema = finalConfig.schema;
+    let validator = undefined;
+    if (schema instanceof zod.z.ZodType) {
+        var _jsonSchema_definitions;
+        // It's a Zod schema!
+        validator = schema;
+        const jsonSchema = zodToJsonSchema(schema, "response");
+        // Wrap in OpenAI Structured Output format
+        // zod-to-json-schema returns { "$schema": "...", "definitions": { "response": { ... } }, "$ref": "#/definitions/response" }
+        // We need to extract the schema part.
+        // Simpler usage for OpenAI: just get the schema object.
+        // Actually, zod-to-json-schema produces a full JSON schema object.
+        // OpenAI expects: { type: "json_schema", json_schema: { name: "...", schema: ... } }
+        // Let's create a clean schema object
+        // NOTE: OpenAI requires strict: true and additionalProperties: false
+        // zod-to-json-schema generally produces compatible schemas but strictness might need tweaking if required by OpenAI.
+        // For now, let's assume "response" as the name.
+        // We'll define a simpler conversion if possible, or trust the user to configure Zod strictly if they want strict mode.
+        // Extract the definition if it exists
+        const actualSchema = ((_jsonSchema_definitions = jsonSchema.definitions) === null || _jsonSchema_definitions === void 0 ? void 0 : _jsonSchema_definitions.response) || jsonSchema;
+        schema = {
+            type: "json_schema",
+            json_schema: {
+                name: "response",
+                schema: actualSchema,
+                strict: true // Try to enable strict mode for OpenAI
+            }
+        };
+    } else if (typeof schema === 'string') {
+        const schemaPath = path.resolve(finalConfig.basePath, schema);
+        try {
+            const schemaContent = await fs.readFile(schemaPath, 'utf-8');
+            schema = JSON.parse(schemaContent);
+        } catch (e) {
+            throw new Error(`Failed to load schema from ${schemaPath}: ${e.message}`);
+        }
     }
     // Build and return prompt
     return create$6({
-        persona: personaSection,
+        persona: personaSection.items.length > 0 ? personaSection : undefined,
         instructions: instructionSection,
-        contents: contentSection,
-        contexts: contextSection
+        contents: contentSection.items.length > 0 ? contentSection : undefined,
+        contexts: contextSection.items.length > 0 ? contextSection : undefined,
+        constraints: constraintSection.items.length > 0 ? constraintSection : undefined,
+        tone: toneSection.items.length > 0 ? toneSection : undefined,
+        examples: exampleSection.items.length > 0 ? exampleSection : undefined,
+        reasoning: reasoningSection.items.length > 0 ? reasoningSection : undefined,
+        responseFormat: responseFormatSection.items.length > 0 ? responseFormatSection : undefined,
+        recap: recapSection.items.length > 0 ? recapSection : undefined,
+        safeguards: safeguardSection.items.length > 0 ? safeguardSection : undefined,
+        schema,
+        validator
     });
 };
 const processContentItem = async (item, section, type, ctx)=>{
@@ -5233,6 +5393,59 @@ const recipe = (basePath)=>{
             ];
             return builder;
         },
+        constraints: (...constraints)=>{
+            config.constraints = [
+                ...config.constraints || [],
+                ...constraints
+            ];
+            return builder;
+        },
+        tone: (...tone)=>{
+            config.tone = [
+                ...config.tone || [],
+                ...tone
+            ];
+            return builder;
+        },
+        examples: (...examples)=>{
+            config.examples = [
+                ...config.examples || [],
+                ...examples
+            ];
+            return builder;
+        },
+        reasoning: (...reasoning)=>{
+            config.reasoning = [
+                ...config.reasoning || [],
+                ...reasoning
+            ];
+            return builder;
+        },
+        responseFormat: (...responseFormat)=>{
+            config.responseFormat = [
+                ...config.responseFormat || [],
+                ...responseFormat
+            ];
+            return builder;
+        },
+        recap: (...recap)=>{
+            config.recap = [
+                ...config.recap || [],
+                ...recap
+            ];
+            return builder;
+        },
+        safeguards: (...safeguards)=>{
+            config.safeguards = [
+                ...config.safeguards || [],
+                ...safeguards
+            ];
+            return builder;
+        },
+        schema: (schema)=>{
+            config.schema = schema;
+            return builder;
+        },
         parameters: (parameters)=>{
             config.parameters = {
                 ...config.parameters,
@@ -5317,12 +5530,604 @@ 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,
+            response_format: request.responseFormat
+        });
+        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 = {}) {
+        var _request_responseFormat, _request_responseFormat1;
+        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,
+            ...((_request_responseFormat = request.responseFormat) === null || _request_responseFormat === void 0 ? void 0 : _request_responseFormat.type) === 'json_schema' ? {
+                tools: [
+                    {
+                        name: request.responseFormat.json_schema.name,
+                        description: request.responseFormat.json_schema.description || "Output data in this structured format",
+                        input_schema: request.responseFormat.json_schema.schema
+                    }
+                ],
+                tool_choice: {
+                    type: 'tool',
+                    name: request.responseFormat.json_schema.name
+                }
+            } : {}
+        });
+        // Handle ContentBlock
+        // Check for tool_use first if we requested structured output
+        let text = '';
+        if (((_request_responseFormat1 = request.responseFormat) === null || _request_responseFormat1 === void 0 ? void 0 : _request_responseFormat1.type) === 'json_schema') {
+            const toolUseBlock = response.content.find((block)=>block.type === 'tool_use');
+            if (toolUseBlock && toolUseBlock.type === 'tool_use') {
+                // Return the structured data as a JSON string to match OpenAI behavior
+                text = JSON.stringify(toolUseBlock.input, null, 2);
+            }
+        } else {
+            const contentBlock = response.content[0];
+            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 = {}) {
+        var _request_responseFormat;
+        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';
+        // Handle generation config for structured output
+        const generationConfig = {};
+        if (((_request_responseFormat = request.responseFormat) === null || _request_responseFormat === void 0 ? void 0 : _request_responseFormat.type) === 'json_schema') {
+            generationConfig.responseMimeType = "application/json";
+            // Map OpenAI JSON schema to Gemini Schema
+            // OpenAI: { name: "...", schema: { type: "object", properties: ... } }
+            // Gemini expects the schema object directly
+            const openAISchema = request.responseFormat.json_schema.schema;
+            // We need to recursively map the types because Gemini uses uppercase enums
+            // SchemaType.OBJECT, SchemaType.STRING, etc.
+            // But the SDK also accepts string types "OBJECT", "STRING" etc.
+            // Let's implement a simple converter or pass it if compatible.
+            // Zod-to-json-schema produces lowercase types ("object", "string").
+            // Google's SDK might need them to be uppercase or mapped.
+            // Helper to clean up schema for Gemini
+            // Removes $schema, strict, and additionalProperties if not supported or formatted differently
+            // And maps 'type' to uppercase.
+            const mapSchema = (s)=>{
+                if (!s) return undefined;
+                const newSchema = {
+                    ...s
+                };
+                if (newSchema.type) {
+                    newSchema.type = typeof newSchema.type === 'string' ? newSchema.type.toUpperCase() : newSchema.type;
+                }
+                if (newSchema.properties) {
+                    const newProps = {};
+                    for (const [key, val] of Object.entries(newSchema.properties)){
+                        newProps[key] = mapSchema(val);
+                    }
+                    newSchema.properties = newProps;
+                }
+                if (newSchema.items) {
+                    newSchema.items = mapSchema(newSchema.items);
+                }
+                // Remove unsupported OpenAI-specific fields if Gemini complains
+                delete newSchema.additionalProperties;
+                delete newSchema['$schema'];
+                return newSchema;
+            };
+            generationConfig.responseSchema = mapSchema(openAISchema);
+        }
+        // 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,
+            generationConfig
+        });
+        // 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 +6139,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;