@riotprompt/riotprompt 0.0.13 → 0.0.14

package/dist/riotprompt.cjs

@@ -5,6 +5,7 @@ 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');
@@ -236,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
     };
 };
 
@@ -519,6 +529,8 @@ const createRequest = (model)=>{
     return {
         model,
         messages,
+        responseFormat: undefined,
+        validator: undefined,
         addMessage: (message)=>{
             messages.push(message);
         }
@@ -671,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
             });
         }
-        let formattedAreas = formatSection(prompt.instructions) + '\n\n';
-        if (prompt.contents) {
-            formattedAreas += formatSection(prompt.contents) + '\n\n';
+        // --- 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';
+            }
         }
-        if (prompt.contexts) {
-            formattedAreas += formatSection(prompt.contexts) + '\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() || " "
+            });
+        }
+        if (prompt.schema) {
+            chatRequest.responseFormat = prompt.schema;
+        }
+        if (prompt.validator) {
+            chatRequest.validator = prompt.validator;
         }
-        chatRequest.addMessage({
-            role: "user",
-            content: formattedAreas
-        });
         return chatRequest;
     };
     return {
@@ -4891,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(),
@@ -5056,6 +5105,13 @@ const cook = async (config)=>{
         instructions: [],
         content: [],
         context: [],
+        constraints: [],
+        tone: [],
+        examples: [],
+        reasoning: [],
+        responseFormat: [],
+        recap: [],
+        safeguards: [],
         ...config
     });
     // Handle template inheritance
@@ -5079,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
             };
         }
     }
@@ -5111,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', {
@@ -5120,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();
@@ -5142,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)=>{
@@ -5243,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,
@@ -5666,7 +5869,8 @@ class OpenAIProvider {
             model: model,
             messages: messages,
             temperature: options.temperature,
-            max_tokens: options.maxTokens
+            max_tokens: options.maxTokens,
+            response_format: request.responseFormat
         });
         const choice = response.choices[0];
         return {
@@ -5682,6 +5886,7 @@ class OpenAIProvider {
 
 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({
@@ -5706,11 +5911,34 @@ class AnthropicProvider {
             system: systemPrompt.trim() || undefined,
             messages: messages,
             max_tokens: options.maxTokens || 4096,
-            temperature: options.temperature
+            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
-        const contentBlock = response.content[0];
-        const text = contentBlock.type === 'text' ? contentBlock.text : '';
+        // 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,
@@ -5724,10 +5952,53 @@ class AnthropicProvider {
 
 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.
@@ -5744,7 +6015,8 @@ class GeminiProvider {
         // 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
+            systemInstruction: systemInstruction ? systemInstruction.trim() : undefined,
+            generationConfig
         });
         // Build history/messages
         // Gemini `generateContent` takes the *last* user message.